{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "04865331",
   "metadata": {},
   "source": [
    "# Discrete Bayes Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "d4f27f1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "805bfa1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <style>\n",
       "        .output_wrapper, .output {\n",
       "            height:auto !important;\n",
       "            max-height:100000px;\n",
       "        }\n",
       "        .output_scroll {\n",
       "            box-shadow:none !important;\n",
       "            webkit-box-shadow:none !important;\n",
       "        }\n",
       "        </style>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#format the book\n",
    "import book_format\n",
    "book_format.set_style()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46237b1e",
   "metadata": {},
   "source": [
    "卡尔曼滤波器属于称为 *贝叶斯滤波器* 的滤波器系列。大多数教科书上对卡尔曼滤波器的处理都提出了贝叶斯公式，也许说明了它是如何影响卡尔曼滤波器方程的，但主要是将讨论保持在非常抽象的层次上。\n",
    "\n",
    "这种方法需要对数学的几个领域有相当精确的理解，而且它仍然把理解和形成对情况的直观掌握的大部分工作留给了读者。\n",
    "\n",
    "我将使用不同的方式来展开这个主题，我非常感谢迪特尔·福克斯和塞巴斯蒂安·特伦的工作。它基于一个穿过走廊的物体的例子，建立对贝叶斯统计如何工作的直觉 - 他们使用机器人，我使用狗。我喜欢狗，它们比机器人更难预测，这给滤波带来了有趣的困难。我能找到的第一个发布的例子似乎是 Fox 1999 [1]，在 Fox 2003 [2] 中有一个更完整的例子。 Sebastian Thrun 在他的优达学城机器人人工智能课程 [3] 中也使用了这个公式。事实上，如果您喜欢看视频，我强烈建议您暂停阅读本书，转而阅读该课程的前几节课，然后再回到本书深入探讨该主题。\n",
    "\n",
    "现在让我们使用一个简单的思想实验，就像我们对 g-h 过滤器所做的一样，看看我们如何推导使用概率进行滤波和跟踪（的过程）。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa532dac",
   "metadata": {},
   "source": [
    "## Tracking a Dog\n",
    "\n",
    "让我们从一个简单的问题开始。我们有一个对狗友好的工作区，所以人们带着他们的狗去上班。偶尔，这些狗会从办公室出来，在大厅里闲逛。我们希望能够跟踪它们。因此，在黑客竞赛期间，有人发明了一种声纳传感器来连接到狗的项圈上。它发出信号，监听回声，根据回声返回的速度，我们可以判断狗是否在敞开的门前。它还可以感知狗何时行走，并报告狗移动的方向。它通过 wifi 连接到网络并每秒发送一次更新。\n",
    "\n",
    "我想跟踪我的狗，西蒙，所以我将设备连接到他的项圈，然后启动 Python，准备编写代码来跟踪他穿过建筑物。乍一看，这似乎是不可能的。如果我开始听 Simon 项圈的感应器，我可能会读到 **door**、**hall**、**hall** 等等。我如何使用这些信息来确定西蒙在哪里？\n",
    "\n",
    "为了使问题足够小以易于绘制，我们将假设走廊中只有 10 个位置，我们将这些位置编号为 0 到 9，其中 1 位于 0 的右侧。出于稍后会清楚的原因，我们还将假设走廊是圆形或矩形。如果您从位置 9 向右移动，您将位于位置 0。\n",
    "\n",
    "当我开始听传感器时，我没有理由相信西蒙在走廊的任何特定位置。从我的角度来看，他在任何位置上（0-9）是等可能的。有 10 个位置，所以他在任何给定位置的概率是 1/10。\n",
    "\n",
    "让我们在 NumPy 数组中代表我们对他的立场的信念。我可以使用 Python 列表，但 NumPy 数组提供了我们很快就会使用的功能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "fdc0e2fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "belief = np.array([1/10]*10)\n",
    "print(belief)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9c6576e",
   "metadata": {},
   "source": [
    "在 [贝叶斯统计](https://en.wikipedia.org/wiki/Bayesian_probability) 中，这称为 [*prior（先验）*](https://en.wikipedia.org/wiki/Prior_probability)。它是在合并测量或其他信息之前的概率。更完整地说，这称为*先验概率分布*。 [*概率分布*](https://en.wikipedia.org/wiki/Probability_distribution) 是事件所有可能概率的集合。概率分布总和为 1，因为必须发生某些事情；分布列出了所有可能的事件和每个事件的概率。\n",
    "\n",
    "我相信你以前用过概率——比如“今天下雨的概率是 30%”。上一段听起来更像如此。但贝叶斯统计是概率的一场革命，因为它将概率视为对单个事件的belief（信念）。让我们举个例子。我知道，如果我无限次地掷一枚公平的硬币，我会得到 50% 的正面和 50% 的反面。这称为 [*frequentist statistics*](https://en.wikipedia.org/wiki/Frequentist_inference) 以区别于贝叶斯统计。计算基于事件发生的频率。\n",
    "\n",
    "我再抛一次硬币，让它落地。我相信它以哪种方式降落？频率论概率对此无话可说。它只会说明 50% 的硬币翻转着陆为正面。在某些方面，为硬币的当前状态分配概率是没有意义的。它要么是正面，要么是反面，我们只是不知道哪个。贝叶斯将此视为对单个事件的信念 - 我的信念或知识的强度，即这次特定的硬币翻转是正面的 50%。有些人反对“belief”这个词；信念可以暗示在没有证据的情况下坚持某事是真实的。在这本书中，它总是衡量我们知识的强度。我们将在前进过程中了解更多相关信息。\n",
    "\n",
    "贝叶斯统计将过去的信息（先验）考虑在内。我们观察到每 100 天下雨 4 次。由此我可以说明天下雨的几率是 1/25。这不是进行天气预报的方式。如果我知道今天正在下雨并且风暴前沿停滞，那么明天可能会下雨。天气预报是贝叶斯的。\n",
    "\n",
    "在实践中，统计学家混合使用频率论和贝叶斯技术。有时找到先验是困难的或不可能的，频率论技术占主导地位。在这本书中，我们可以找到先验。当我谈论某事的概率时，我指的是在给定过去事件的情况下某些特定事物为真的概率。当我这样做时，我正在采用贝叶斯方法。\n",
    "\n",
    "现在让我们创建一张走廊的地图。我们将把前两扇门靠近在一起，然后再把另一扇门放在更远的地方。我们将 1 用于门，0 用于墙壁："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "4891a6cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "hallway = np.array([1, 1, 0, 0, 0, 0, 0, 0, 1, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "606fffbd",
   "metadata": {},
   "source": [
    "我开始在网络上收听西蒙的传输（的位置信息），我从传感器得到的第一个数据是**门**。 目前假设传感器总是返回正确的答案。 由此我得出结论，他是在一扇门前，但是是哪一扇门？ 我没有理由相信他在第一、第二或第三扇门前。 我能做的就是为每个门分配一个概率。 所有的门都是等概率的，一共有三个，所以我给每个门分配了 1/3 的概率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "id": "0aeb2db2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import kf_book.book_plots as book_plots\n",
    "from kf_book.book_plots import figsize, set_figsize\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "belief = np.array([1/3, 1/3, 0, 0, 0, 0, 0, 0, 1/3, 0])\n",
    "book_plots.bar_plot(belief)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "befa7152",
   "metadata": {},
   "source": [
    "这种分布称为 [*categorical distribution*](https://en.wikipedia.org/wiki/Categorical_distribution)，它是描述观察 $n$ 结果的概率的离散分布。这是一个 [*多峰分布*](https://en.wikipedia.org/wiki/Multimodal_distribution) 因为我们对我们的狗的位置有多种信念。当然，我们并不是说我们认为他同时在三个不同的地点，只是我们将知识范围缩小到这三个地点之一。我的（贝叶斯）信念是，有 33.3% 的机会在 0 号门，33.3% 在 1 号门，33.3% 的机会在 8 号门。\n",
    "\n",
    "这是两个方面的改进。我已经拒绝了一些走廊位置的可能性，而我对其余位置的信心从 10% 增加到 33%。这将永远发生。随着我们知识的提高，概率将接近 100%。\n",
    "\n",
    "关于 [*mode*] 的几句话(https://en.wikipedia.org/wiki/Mode_%28statistics%29)\n",
    "的分布。给定一个数字列表，例如 {1, 2, 2, 2, 3, 3, 4}，*mode* 是最常出现的数字。对于该集合，众数为 2。一个分布可以包含多个众数。列表 {1, 2, 2, 2, 3, 3, 4, 4, 4} 包含模式 2 和 4，因为两者都出现了 3 次。我们说前者是[*unimodal（单峰）*](https://en.wikipedia.org/wiki/Unimodality)，后者是*multimodal（多峰）*。\n",
    "\n",
    "用于此分布的另一个术语是 [*histogram（直方图）*](https://en.wikipedia.org/wiki/Histogram)。直方图以图形方式描绘了一组数字的分布。上面的条形图是直方图。\n",
    "\n",
    "我在上面的代码中手动编码了 `belief` 数组。我们将如何在代码中实现这一点？我们用 1 表示门，用 0 表示墙壁，所以我们将走廊变量乘以百分比，就像这样；"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "id": "9323ce63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.333 0.333 0.    0.    0.    0.    0.    0.    0.333 0.   ]\n"
     ]
    }
   ],
   "source": [
    "belief = hallway * (1/3)\n",
    "print(belief)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d2cbe8f",
   "metadata": {},
   "source": [
    "## Extracting Information from Sensor Readings\n",
    "\n",
    "让我们把 Python 放在一边，稍微思考一下这个问题。 假设我们要从 Simon 的传感器中读取以下内容：\n",
    "\n",
    "   * 门\n",
    "   * 向右移\n",
    "   * 门\n",
    "  \n",
    "\n",
    "我们能推断出西蒙的位置吗？ 当然！ 考虑到走廊的布局，只有一个地方可以得到这个序列，那就是左端。 因此，我们可以自信地说西蒙在第二个门口。 如果这不清楚，假设西蒙是从第二个或第三个门开始的。 向右移动后，他的传感器会返回“墙”。 这与传感器读数不符，所以我们知道他不是从那里开始的。 我们可以对所有剩余的起始位置继续使用该逻辑。 唯一的可能就是，他现在就在第二道门前。 我们的信念是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "c5f7e2ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "belief = np.array([0., 1., 0., 0., 0., 0., 0., 0., 0., 0.])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "875a7610",
   "metadata": {},
   "source": [
    "我设计了走廊布局和传感器读数，以便快速给我们一个准确的答案。 真正的问题并没有那么明确。 但这应该会触发你的直觉——第一个传感器读数只给我们提供了西蒙位置的低概率 (0.333)，但在位置更新和另一个传感器读数之后，我们对他的位置有了更多的了解。 您可能会正确地怀疑，如果您有一个非常长的走廊和大量的门，经过多次传感器读数和位置更新后，我们是否还能够知道西蒙在哪里，或者（估计的）可能性将缩小到一个很小的数字。 （但是）当一组传感器读数仅匹配一个到几个起始位置时，这是可能的。\n",
    "\n",
    "我们现在可以实施这个解决方案，但让我们考虑一下这个问题的现实世界的复杂性。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be0864c3",
   "metadata": {},
   "source": [
    "## Noisy Sensors\n",
    "\n",
    "完美的传感器很少见。 如果西蒙坐在门前抓挠自己，或者如果他没有面向走廊，传感器可能不会检测到门。 因此，当我得到 **door** 时，我不能使用 1/3 作为概率。 我必须为每个门分配小于 1/3 的概率，并为每个空白墙位置分配一个小概率。 就像是\n",
    "\n",
    "```Python\n",
    "[.31, .31, .01, .01, .01, .01, .01, .01, .31, .01]\n",
    "```\n",
    "\n",
    "乍一看，这似乎是不可逾越的。如果传感器有噪音，它就会对每条数据产生怀疑。如果我们总是不确定，我们怎么能得出结论呢？\n",
    "\n",
    "对于上面的问题，答案是概率。我们已经习惯于为狗的位置分配一个概率信念；现在我们必须考虑由传感器噪声引起的额外不确定性。\n",
    "\n",
    "假设我们得到 **door** 的读数，并假设测试表明传感器正确的可能性是错误的 3 倍。我们应该在有门的地方将概率分布缩放 3。如果我们这样做，结果将不再是概率分布，但我们稍后将学习如何解决这个问题。（这里我的理解是，传感器出现状态错误报送的概率是25%     ）\n",
    "\n",
    "让我们看看 Python 代码。在这里，我使用变量 `z` 来表示测量值。 `z` 或 `y` 是文献中用于测量的习惯选择。作为程序员，我更喜欢有意义的变量名，但我希望您能够阅读文献和/或其他滤波代码，因此我现在将开始介绍这些缩写名称。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "id": "a38eb239",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "belief: [0.3 0.3 0.1 0.1 0.1 0.1 0.1 0.1 0.3 0.1]\n",
      "sum = 1.6000000000000003\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def update_belief(hall, belief, z, correct_scale):\n",
    "    for i, val in enumerate(hall):\n",
    "        if val == z:\n",
    "            belief[i] *= correct_scale\n",
    "\n",
    "belief = np.array([0.1] * 10)\n",
    "reading = 1 # 1 is 'door'\n",
    "update_belief(hallway, belief, z=reading, correct_scale=3.)\n",
    "print('belief:', belief)\n",
    "print('sum =', sum(belief))\n",
    "plt.figure()\n",
    "book_plots.bar_plot(belief)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ebaa369",
   "metadata": {},
   "source": [
    "这不是概率分布，因为它的总和不为 1.0。 但代码做的大多是正确的 - 门被分配了一个比墙高 3 倍的数字 (0.3) (0.1)。 我们需要做的就是对结果进行归一化，以便概率之和正确地为 1.0。 标准化是通过将每个元素除以列表中所有元素的总和来完成的。 使用 NumPy 这很容易："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "id": "5e5c0be2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.188, 0.188, 0.062, 0.062, 0.062, 0.062, 0.062, 0.062, 0.188,\n",
       "       0.062])"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "belief / sum(belief)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57d1f7f8",
   "metadata": {},
   "source": [
    "FilterPy 使用 `normalize` 函数实现了这一点：\n",
    "\n",
    "```Python\n",
    "from filterpy.discrete_bayes import normalize\n",
    "normalize(belief)\n",
    "```\n",
    "\n",
    "说“正确的可能性是错误的 3 倍”有点奇怪。 我们正在研究概率，所以让我们指定传感器正确的概率，并从中计算比例因子。 方程是\n",
    "\n",
    "$$scale =  \\frac{prob_{correct}}{prob_{incorrect}} = \\frac{prob_{correct}} {1-prob_{correct}}$$\n",
    "\n",
    "\n",
    "此外，`for` 循环很麻烦。 作为一般规则，您将希望避免在 NumPy 代码中使用 `for` 循环。 NumPy 是用 C 和 Fortran 实现的，所以如果你避免 for 循环，结果的运行速度通常比等效循环快 100 倍。\n",
    "\n",
    "我们如何摆脱这个 `for` 循环？ NumPy 允许您使用布尔数组索引数组。 您创建一个带有逻辑运算符的布尔数组。 我们可以找到走廊里的所有门："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "id": "b05f99e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False, False, False, False, False, False,  True,\n",
       "       False])"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hallway == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1458ce84",
   "metadata": {},
   "source": [
    "当您使用布尔数组作为另一个数组的索引时，它仅返回索引为“True”的元素。 因此，我们可以将 `for` 循环替换为\n",
    "\n",
    "```python\n",
    "belief[hall==z] *= scale\n",
    "```\n",
    "\n",
    "并且只有等于 `z` 的元素才会乘以 `scale`。\n",
    "\n",
    "教你 NumPy 超出了本书的范围。 我将使用惯用的 NumPy 结构并在我第一次展示它们时解释它们。 如果您是 NumPy 的新手，这里有很多关于如何有效和惯用地使用 NumPy 的博客文章和视频。\n",
    "\n",
    "这是我们改进的版本：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "id": "ea50d506",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum = 1.0\n",
      "probability of door = 0.1875\n",
      "probability of wall = 0.06249999999999999\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from filterpy.discrete_bayes import normalize\n",
    "\n",
    "def scaled_update(hall, belief, z, z_prob): \n",
    "    scale = z_prob / (1. - z_prob)\n",
    "    belief[hall==z] *= scale\n",
    "    normalize(belief)\n",
    "\n",
    "belief = np.array([0.1] * 10)\n",
    "scaled_update(hallway, belief, z=1, z_prob=.75)\n",
    "\n",
    "print('sum =', sum(belief))\n",
    "print('probability of door =', belief[0])\n",
    "print('probability of wall =', belief[2])\n",
    "book_plots.bar_plot(belief, ylim=(0, .3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b1585da",
   "metadata": {},
   "source": [
    "我们可以从输出中看到总和现在是 1.0，门对墙的概率仍然是三倍。结果也符合我们的直觉，门的概率必须小于 0.333，墙的概率必须大于 0.0。最后，它应该符合我们的直觉，我们还没有获得任何信息可以让我们区分任何给定的门或墙壁位置，因此所有门位置都应该具有相同的值，并且墙壁位置也应该如此。（上面这个过程对应于获得第一个传感器的信息是门）\n",
    " \n",
    "这个结果被称为 [*posterior（后验）*](https://en.wikipedia.org/wiki/Posterior_probability)，它是*后验概率分布*的缩写。所有这些意味着是一个纳入测量信息后（ *after* ）的概率分布 （posterior 在这种情况下意味着“之后”）。回顾一下，*prior* 是包括测量信息之前的概率分布。\n",
    "\n",
    "另一个术语是 [*likelihood（似然）*](https://en.wikipedia.org/wiki/Likelihood_function)。当我们计算 `belief[hall==z] *= scale` 时，我们正在计算每个位置的 *可能* 测量值。似然不是概率分布，因为它的总和不等于 1。（似然进行了对应状态置信更新，但是没有归一化？）\n",
    "\n",
    "这些的组合给出了等式\n",
    "\n",
    "$$\\mathtt{posterior} = \\frac{\\mathtt{likelihood} \\times \\mathtt{prior}}{\\mathtt{normalization}}$$ \n",
    "\n",
    "当我们谈论滤波器的输出时，我们通常将执行预测后的状态称为 *prior* 或 *prediction*，我们将更新后的状态称为 *posterior* 或 *estimated state*。\n",
    "\n",
    "学习和内化这些术语非常重要，因为大多数文献都广泛使用它们。\n",
    "\n",
    "`scaled_update()` 是否执行此计算？ 确实如此。 让我把它改写成这个形式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "id": "f7c2a9c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scaled_update(hall, belief, z, z_prob): \n",
    "    scale = z_prob / (1. - z_prob)\n",
    "    likelihood = np.ones(len(hall))\n",
    "    likelihood[hall==z] *= scale\n",
    "    return normalize(likelihood * belief)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb5fefbc",
   "metadata": {},
   "source": [
    "这个功能并不完全通用。 它包含有关走廊的知识，以及我们如何将测量与其匹配。 我们总是致力于撰写一个通用函数。 在这里，我们将从函数中删除似然的计算，并要求调用者自己计算似然。\n",
    "\n",
    "这是算法的完整实现：\n",
    "\n",
    "```python\n",
    "def update(likelihood, prior):\n",
    "    return normalize(likelihood * prior)\n",
    "```\n",
    "\n",
    "可能性的计算因问题而异。 例如，传感器可能不会只返回 1 或 0，而是一个介于 0 和 1 之间的“浮点数”，表示在门前的概率。 它可能会使用计算机视觉并当检测到一个斑点形状，然后将概率匹配到一扇门。 它可能会使用声纳并返回距离读数。 在每种情况下，可能性的计算都会不同。 我们将在整本书中看到许多这样的例子，并学习如何执行这些计算。\n",
    "\n",
    "FilterPy 实现了“更新”。 这是上一个完全通用形式的示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "ca30e53d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3. 3. 1. 1. 1. 1. 1. 1. 3. 1.]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.188, 0.188, 0.062, 0.062, 0.062, 0.062, 0.062, 0.062, 0.188,\n",
       "       0.062])"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from filterpy.discrete_bayes import update\n",
    "\n",
    "def lh_hallway(hall, z, z_prob):\n",
    "    \"\"\" compute likelihood that a measurement matches\n",
    "    positions in the hallway.\"\"\"\n",
    "    \n",
    "    try:\n",
    "        scale = z_prob / (1. - z_prob)\n",
    "    except ZeroDivisionError:\n",
    "        scale = 1e8\n",
    "\n",
    "    likelihood = np.ones(len(hall))\n",
    "    likelihood[hall==z] *= scale\n",
    "    return likelihood\n",
    "\n",
    "belief = np.array([0.1] * 10)\n",
    "likelihood = lh_hallway(hallway, z=1, z_prob=.75)\n",
    "print(likelihood)\n",
    "# 逐点相乘\n",
    "update(likelihood, belief)  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53312b15",
   "metadata": {},
   "source": [
    "## Sction 2.4 Incorporating Movement \n",
    "回想一下，当我们结合一系列测量和运动更新时，我们能够以多快的速度找到准确的解决方案。然而，这发生在一个完美传感器的虚构世界中。我们能否找到带有噪声传感器的精确解决方案？\n",
    "（带噪声的不能找到精确解）\n",
    "不幸的是，答案是否定的。即使传感器读数与极其复杂的走廊地图完美匹配，我们也不能 100% 确定狗处于特定位置 - 毕竟，每个传感器读数都有微小的可能性出现错误！当然，在更典型的情况下，大多数传感器读数都是正确的，我们可能接近 100% 确定我们的答案，但永远不会 100% 确定。这可能看起来很复杂，但让我们继续编写数学程序。\n",
    "\n",
    "首先让我们处理一个简单的情况 ----> 假设运动传感器是完美的，它报告狗已经向右移动了一个空间。我们将如何改变我们的 “belief” 数组？\n",
    "\n",
    "我希望经过片刻的思考后，我们应该将所有值向右移动一个空间。如果我们之前认为 Simon 有 50% 的机会在位置 3，那么在他向右移动一个位置后，我们应该相信他有 50% 的机会在位置 4。走廊是圆形的，所以我们将使用模运算（%）来执行移位。(首尾相接)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "0b7dd339",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import kf_book.book_plots as book_plots\n",
    "def perfect_predict(belief, move):\n",
    "    \"\"\" move the position by `move` spaces, where positive is \n",
    "    to the right, and negative is to the left\n",
    "    \"\"\"\n",
    "    n = len(belief)\n",
    "    result = np.zeros(n)\n",
    "    for i in range(n):\n",
    "        result[i] = belief[(i-move) % n] # (i-move) % n 表示旧的位置的索引  （因为是环状的）\n",
    "        print((i-move) % n, i-move)\n",
    "    return result\n",
    "        \n",
    "belief = np.array([.35, .1, .2, .3, 0, 0, 0, 0, 0, .05])\n",
    "plt.subplot(121)\n",
    "book_plots.bar_plot(belief, title='Before prediction', ylim=(0, .4))\n",
    "\n",
    "belief = perfect_predict(belief, 1)\n",
    "plt.subplot(122)\n",
    "book_plots.bar_plot(belief, title='After prediction', ylim=(0, .4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffc0f118",
   "metadata": {},
   "source": [
    "我们可以看到我们正确地将所有值向右移动了一个位置，从数组的末尾换回了开头。\n",
    "\n",
    "下一个单元格对此进行动画处理，以便您可以看到它的运行情况。 使用滑块在时间上前后移动。 这模拟了西蒙在走廊里走来走去。 它尚未包含新的测量值，因此概率分布不会改变形状，只会改变位置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "id": "bf4bca19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 -1\n",
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4d93d5a264cf43fd92f5758b0064427f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='time_step', max=19), Output()), _dom_classes=('widget-in…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ipywidgets import interact, IntSlider\n",
    "\n",
    "belief = np.array([.35, .1, .2, .3, 0, 0, 0, 0, 0, .05])\n",
    "perfect_beliefs = []\n",
    "\n",
    "for _ in range(20):\n",
    "    # Simon takes one step to the right\n",
    "    belief = perfect_predict(belief, 1)\n",
    "    perfect_beliefs.append(belief)\n",
    "\n",
    "def simulate(time_step):\n",
    "    book_plots.bar_plot(perfect_beliefs[time_step], ylim=(0, .4))\n",
    "    \n",
    "interact(simulate, time_step=IntSlider(value=0, max=len(perfect_beliefs)-1));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25e066b6",
   "metadata": {},
   "source": [
    "## Section 2.5: Terminology 术语\n",
    "\n",
    "让我们停下来回顾一下术语。我在上一章中介绍了这个术语，但让我们花点时间来巩固您的知识。\n",
    "\n",
    "*system* 是我们试图建模或滤波的（对象）。这里的系统是狗。 *state* 是它（system）的当前 configuration 或 value。在本章中，state是我们的狗的位置。我们很少知道实际state，所以我们说我们的滤波器产生系统的*estimated state*。在实践中，这通常被称为state，所以要小心理解上下文。\n",
    " \n",
    "使用测量进行预测和更新的一个循环称为state或system ** 演化（evolution）** ，它是 ** 时间演化（time evolution）** 的缩写[7]。另一个术语是 *系统传播（system propagation）* 。它指的是系统状态（system state）如何随时间变化。对于滤波器，时间通常是一个离散的步长，例如 1 秒。对于我们的狗追踪器，系统状态（system state）是狗的位置，状态演化是经过离散时间后的位置。\n",
    "\n",
    "我们使用*过程模型(process model)*对系统行为进行建模。在这里，我们的process model是狗在每个时间步移动一个或多个位置。这不是关于狗行为的特别准确的模型。模型中的误差（error）称为*系统误差 system error *或*过程误差 process error*。\n",
    "\n",
    "预测是我们新的*先验（prior）*：时间推进下，当在不知道测量结果的情况下做出了预测（对先验的解释）。 *补充*： 也可以解释为基于已有条件在的预测判断，请回忆以下天气预报的例子\n",
    "\n",
    "让我们举一个例子。 狗的当前位置是 17 m。 我们的epoch是 2 秒，狗以 15 m/s 的速度行进。 预测他两秒钟后会在哪里？\n",
    "\n",
    "** 注：** 系统传播和测量更新的一次迭代称为*epoch*。（将预测和测量值融合）One iteration of the system propagation and measurement update is known as an epoch.\n",
    "\n",
    "清楚地，\n",
    "\n",
    "$$ \\begin{aligned}\n",
    "\\bar x &= 17 + (15*2) \\\\\n",
    "&= 47\n",
    "\\end{aligned}$$\n",
    "\n",
    "\n",
    "我在变量上使用上划线来表示它们是先验（预测）。 我们可以像这样写出过程模型的方程(quation for the process model)：\n",
    "\n",
    "$$ \\bar x_{k+1} = f_x(\\bullet) + x_k$$\n",
    "\n",
    "\n",
    "$x_k$ 是当前位置或状态。 如果狗在 17 m 处，则 $x_k = 17$。\n",
    "\n",
    "$f_x(\\bullet)$ 是 x 的状态传播函数（state propagation/system propagation function）。 它描述了 $x_k$ 在一个时间步长内的变化程度。 对于我们的示例，它执行计算 $15 \\cdot 2$ 因此我们将其定义为\n",
    "\n",
    "$$f_x(v_x, t) = v_k t$$\n",
    "\n",
    "**注意：以上只出现了基于先验的预测，还不是一个完整的epoch**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b80d7195",
   "metadata": {},
   "source": [
    "## Section 2.6： Adding Uncertainty to the Prediction\n",
    "\n",
    "`perfect_predict()` 假设测量完美，但所有传感器都有噪声。 如果传感器报告我们的狗移动了一个空格，但它实际上移动了两个空格或零，该怎么办？ 这听起来像是一个无法解决的问题，但让我们对其进行建模，看看会发生什么。\n",
    "\n",
    "假设传感器的运动测量有 80% 的可能是正确的，有 10% 可能性比当前位置再向右一格（overshoot），有 10% 可能性比当前位置再向左一格（undershoot）。 也就是说，如果移动测量值为 4（即向右移动 4 个格），则狗向右移动 4 个格的可能性为 80%，向右移动 3 个格的可能性为 10%（undershoot），向右移动 5 个格的可能性为 10%（overshoot）。\n",
    "\n",
    "数组中的每个结果现在都需要包含 3 种不同情况的概率。 例如，考虑收到的移动（信息）是2步（2格）。如果我们 100% 确定狗从位置 3 开始，那么他有 80% 的机会在 5，10% 的机会在 4 或 6。让我们尝试撰写代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "id": "c3acec9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def predict_move(belief, move, p_under, p_correct, p_over):\n",
    "    n = len(belief)\n",
    "    prior = np.zeros(n)\n",
    "    # 对所有先验全部更新\n",
    "    for i in range(n):\n",
    "        prior[i] = (\n",
    "            belief[(i-move) % n]   * p_correct +\n",
    "            belief[(i-move-1) % n] * p_over +\n",
    "            belief[(i-move+1) % n] * p_under)      \n",
    "    return prior\n",
    "\n",
    "belief = [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.]\n",
    "prior = predict_move(belief, 2, .1, .8, .1)\n",
    "book_plots.plot_belief_vs_prior(belief, prior)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "524fd79e",
   "metadata": {},
   "source": [
    "它似乎可以正常工作。 现在当我们的信念不是 100% 确定时会发生什么？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "1f79b77e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.  , 0.  , 0.04, 0.38, 0.52, 0.06, 0.  , 0.  , 0.  ])"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "belief = [0, 0, .4, .6, 0, 0, 0, 0, 0, 0]\n",
    "prior = predict_move(belief, 2, .1, .8, .1)\n",
    "book_plots.plot_belief_vs_prior(belief, prior)\n",
    "prior"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c3ebf78",
   "metadata": {},
   "source": [
    "这里的结果更复杂，但您仍然应该能够在头脑中解决它。 0.04 是由于 0.4 置信度时发生undershoot 1 的可能性（ **注：** 这个0.04源于在开始2位置上，0.4的概率，且由于返回移动的两个步长存在0.1的向左的一个概率 ）。0.38 是由于以下原因：我们移动 2 个头寸 (0.4 $\\times$ 0.8) 的可能性为 80%，我们低于 (0.6) 的可能性为 10% $\\times$ 0.1）（ **注：** 即源于开始2位置正确移动2步+初始3位置 undershoot 向左移动一格的偏差）。overshoot 在这里没有任何作用，因为如果我们overshoot 0.4 和 0.6 都会超过这个位置。 **我强烈建议做一些例子，直到所有这些都非常清楚，因为接下来的很多事情都取决于对这一步的理解。**\n",
    "\n",
    "如果您在执行更新后查看概率，您可能会感到沮丧。在上面的例子中，我们从两个位置的概率 0.4 和 0.6 开始；执行更新后，概率不仅降低，而且散布在整个地图上。\n",
    "\n",
    "这不是巧合，也不是精心选择的例子的结果——这是真实的预测结果。如果传感器有噪音，我们会在每次预测时丢失一些信息。假设我们要进行无限次预测——结果会是什么？如果我们在每一步都丢失了信息，我们最终将没有一点（有用的）信息，并且我们的概率将在“信念”数组中平均分布。让我们尝试 100 次迭代。情节是动画的；使用滑块更改步骤编号。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "id": "aee4d3c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Belief: [0.104 0.103 0.101 0.099 0.097 0.096 0.097 0.099 0.101 0.103]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5a5099c00dd48d8b6f3a4fa7e276412",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=1, description='step'), Output()), _dom_classes=('widget-interact',))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "belief = np.array([1.0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
    "predict_beliefs = []\n",
    "    \n",
    "for i in range(100):\n",
    "    belief = predict_move(belief, 1, .1, .8, .1)\n",
    "    predict_beliefs.append(belief)\n",
    "\n",
    "print('Final Belief:', belief)\n",
    "\n",
    "# make interactive plot\n",
    "def show_prior(step):\n",
    "    book_plots.bar_plot(predict_beliefs[step-1])\n",
    "    plt.title(f'Step {step}')\n",
    "\n",
    "interact(show_prior, step=IntSlider(value=1, max=len(predict_beliefs)));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "6d174623",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Belief: [0.104 0.103 0.101 0.099 0.097 0.096 0.097 0.099 0.101 0.103]\n"
     ]
    }
   ],
   "source": [
    "print('Final Belief:', belief)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b47ae84a",
   "metadata": {},
   "source": [
    "经过 100 次迭代后，我们几乎丢失了所有信息，尽管我们 100% 确定我们从位置 0 开始。请随意使用数字以查看不同更新次数的效果。 例如，在 100 次更新后只剩下少量信息，在 50 次后还剩下很多，但经过 200 次迭代，基本上所有信息都丢失了。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9306b21",
   "metadata": {},
   "source": [
    "而且，如果您在线查看此内容，则此处是该输出的动画。\n",
    "<img src=\"animations/02_no_info.gif\">\n",
    "\n",
    "我不会在本书的其余部分生成这些独立的动画。 请参阅前言以获取在 Web 上免费运行本书的说明，或在您的计算机上安装 IPython。 这将允许您运行所有单元格并查看动画。 使用此代码练习非常重要，而不仅仅是被动阅读。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c07ec30",
   "metadata": {},
   "source": [
    "## Section 2.7：Generalizing with Convolution  使用卷积进行推广（泛化）\n",
    "\n",
    "我们假设移动误差至多是一个位置（上一节的分析假设的误差）。 但误差可能是两个、三个或更多位置。 作为程序员，我们总是希望泛化我们的代码，使其适用于所有情况。\n",
    "\n",
    "这可以通过 [*convolution*](https://en.wikipedia.org/wiki/Convolution) 轻松解决。 卷积用另一个函数修改一个函数。 \n",
    "在我们的例子中，我们正在用传感器的误差函数修改概率分布。 `predict_move()` 的实现是一个卷积，虽然我们没有这样称呼它。 形式上，卷积定义为\n",
    "\n",
    "$$ (f \\ast g) (t) = \\int_0^t \\!f(\\tau) \\, g(t-\\tau) \\, \\mathrm{d}\\tau$$\n",
    "\n",
    "其中 $f\\ast g$ 是 f 乘 g 的卷积符号。 这并不意味着乘法。\n",
    "\n",
    "积分适用于连续函数，但我们使用的是离散函数。 我们用求和代替积分，用数组括号代替括号。（f是卷积核核函数）\n",
    "\n",
    "$$ (f \\ast g) [t] = \\sum\\limits_{\\tau=0}^t \\!f[\\tau] \\, g[t-\\tau]$$\n",
    "\n",
    "比较表明`predict_move()` 正在计算这个方程——它计算一系列乘法的总和。\n",
    "\n",
    "``` python\n",
    "def predict_move(belief, move, p_under, p_correct, p_over):\n",
    "    n = len(belief)\n",
    "    prior = np.zeros(n)\n",
    "    # 对所有先验全部更新\n",
    "    for i in range(n):\n",
    "        prior[i] = (\n",
    "            belief[(i-move) % n]   * p_correct +\n",
    "            belief[(i-move-1) % n] * p_over +\n",
    "            belief[(i-move+1) % n] * p_under)      \n",
    "    return prior\n",
    "```\n",
    "\n",
    "[可汗学院](https://www.khanacademy.org/math/differential-equations/laplace-transform/convolution-integral/v/introduction-to-the-convolution) [4] 对卷积有很好的介绍，和 维基百科有一些优秀的卷积动画[5]。 但是大体思路已经很清楚了。 您将一个名为 *kernel* 的数组滑过另一个数组，将当前单元格的邻居与第二个数组的值相乘。 在上面的示例中，我们使用 0.8 表示移动到正确位置的概率，0.1 表示下冲（undershoot），0.1 表示过冲（overshoot）。 我们用数组 `[0.1, 0.8, 0.1]` 制作了一个内核（卷积核）。 我们需要做的就是编写一个循环，遍历数组的每个元素，乘以内核，然后对结果求和。 为了强调信念（belief）是一种概率分布，我将其命名为“pdf”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "34ae53f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_move_convolution(pdf, offset, kernel):\n",
    "    N = len(pdf)\n",
    "    kN = len(kernel)\n",
    "    width = int((kN - 1) / 2)\n",
    "    # print(\"width:\", width)\n",
    "    prior = np.zeros(N)\n",
    "    for i in range(N):\n",
    "        print(\"----------------逐点乘法进行累加---------------------------\")\n",
    "        for k in range (kN):\n",
    "            index = (i + (width - k) - offset) % N\n",
    "            # print(i, index, k)\n",
    "            prior[i] += pdf[index] * kernel[k]\n",
    "    return prior"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ea578ec",
   "metadata": {},
   "source": [
    "上述代码说明了算法，但它运行得非常慢。 SciPy 在 `ndimage.filters` 模块中提供了一个卷积例程 `convolve()`。 我们需要在卷积之前将 pdf 偏移 `offset`； `np.roll()` 就是这样做的。 移动和预测算法可以用一行来实现：\n",
    "\n",
    "```python\n",
    "convolve(np.roll(pdf, offset), kernel, mode='wrap')\n",
    "```\n",
    "\n",
    "FilterPy 使用 `discrete_bayes`'`predict()` 函数实现了这一点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "a942fb00",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu0AAAF2CAYAAADa96Z6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtkElEQVR4nO3de3TU9Z3/8ddkSCZEiQiBBEIgghcMlmATE/GGuwaouNVsL6JSyUbFs0I82NkqZG1J8NLgpUhXo6hddAsi6Vovuy0CaRR2XWKjXNSioFQQNpoLRQgm3cmY+fz+6I/YkID5JvOd+ZA8H+fknM6X73xfn8+A73l1MpN4jDFGAAAAAKwVE+0FAAAAADgxSjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKO/qM0tJSeTweHThwICzX+4d/+Aelp6d3OObxeFRaWtqj69XX1+t73/uehg4dKo/Ho2XLlvV6jQCA8OjNfAciYUC0FwD0Fz/84Q+1fv16lZSUKCUlRdnZ2dFeEgAAOElQ2gEH/vznP2vAgJ79Z/Paa6/pmmuu0Y9+9KMwrwoA0Fu9me9AJPD2GMCB+Pj4Hg/1hoYGDR48OLwLAgD0WCgU0v/93/9J6t18P1Zzc3NYrgP8NUo7+pwDBw7o2muvVWJiooYOHar58+e3D+WjVq1apaysLA0cOFBDhgzRddddp/3793/ttbt6z2Ntba1uuukmJScny+fzacKECVqxYkX7nz/77LPyeDwyxqi8vFwej0cejycsewUAfPWZpp07d55w/ns8HhUVFem5557ThAkT5PP5tG7duvY/O3a+b9u2TVdeeaUSExN16qmn6oorrtCbb77Z4ZyjM37Tpk2aO3euhg8frlGjRrm+Z/Q/fB8Ifc61116r9PR0lZWV6c0339S//Mu/6PPPP9cvf/lLSdL999+vn/zkJ7r22mt1yy23qLGxUY8++qguu+wybdu2zdGr4fX19brwwgvbnwiGDRumV199VTfffLOampp0xx136LLLLtPKlSt14403aurUqZo9e7ZLOweA/u3r5r/0l7cq/upXv1JRUZGSkpI6/cCBo3bs2KFLL71UiYmJuuuuuxQbG6snn3xSl19+uTZt2qTc3NwO58+dO1fDhg3TokWLeKUd7jBAH1FSUmIkmauvvrrD8blz5xpJ5p133jF79+41Xq/X3H///R3Oee+998yAAQM6HC8oKDBjxozpcJ4kU1JS0n775ptvNiNGjDAHDhzocN51111nTjvtNNPS0tLhvvPmzevlLgEAx+rO/DfmL3M4JibG7Nixo9M1jp3v+fn5Ji4uzvzxj39sP/bpp5+aQYMGmcsuu6z92DPPPGMkmUsuucR8+eWXYd4Z8BXeHoM+Z968eR1u33777ZKktWvX6sUXX1QoFNK1116rAwcOtH+lpKTorLPO0uuvv97tHGOMfv3rX+vb3/62jDEdrjd9+nQdPnxYW7duDeveAADHd6L5f9SUKVOUkZFxwuu0tbVpw4YNys/P19ixY9uPjxgxQjfccIPeeOMNNTU1dbjPnDlz5PV6e7sF4Lh4ewz6nLPOOqvD7XHjxikmJkZ79+5VTEyMjDGdzjkqNja22zmNjY06dOiQnnrqKT311FNdntPQ0ND9hQMAeuVE8/+oM84442uv09jYqJaWFp1zzjmd/uzcc89VKBTS/v37NWHCBEfXBXqD0o4+768/9BkKheTxePTqq692+YrIqaee2u3rhkIhSdIPfvADFRQUdHnOxIkTHa4WABAuXX3of+DAga5kuXVd4ChKO/qcjz76qMMrHrt371YoFFJ6erq8Xq+MMTrjjDN09tln9ypn2LBhGjRokNra2pSXl9fbZQMAeulE89+JYcOGKSEhQbt27er0Zzt37lRMTIzS0tJ6u1zAEd7Tjj6nvLy8w+1HH31UknTllVfqO9/5jrxerxYvXixjTIfzjDH605/+1O0cr9er7373u/r1r3+tP/zhD53+vLGxsQerBwD01InmvxNer1fTpk3TK6+80uGtNfX19Vq9erUuueQSJSYm9nq9gBO80o4+Z8+ePbr66qv1rW99S9XV1Vq1apVuuOEGZWZmSpLuu+8+FRcXa+/evcrPz9egQYO0Z88evfTSS7r11lsd/cbSJUuW6PXXX1dubq7mzJmjjIwMHTx4UFu3btXvfvc7HTx40K1tAgCO8XXz34n77rtPlZWVuuSSSzR37lwNGDBATz75pAKBgB588EEXVg+cGKUdfU5FRYUWLVqkhQsXasCAASoqKtJDDz3U/ucLFy7U2WefrUceeUSLFy+WJKWlpWnatGm6+uqrHWUlJyerpqZG99xzj1588UU9/vjjGjp0qCZMmKAHHnggrPsCAJzY181/JyZMmKD//u//VnFxscrKyhQKhZSbm6tVq1Z1+hntQCR4zLHvEQAAADiJlJaWavHixWpsbFRSUlK0lwO4gve0AwAAAJajtAMAAACWo7QDAAAAlutRaS8vL1d6erri4+OVm5urmpqaE55/6NAhzZs3TyNGjJDP59PZZ5/d4VcKAwDsxLzHyaC0tFTGGN7Pjj7N8U+PqaiokN/v1/Lly5Wbm6tly5Zp+vTp2rVrl4YPH97p/NbWVk2dOlXDhw/XCy+8oNTUVH3yyScaPHhwONYPAHAJ8x4A7OH4p8fk5ubqggsu0GOPPSbpL7/KPS0tTbfffrsWLlzY6fzly5froYce0s6dOxUbGxueVQMAXMe8BwB7OCrtra2tSkhI0AsvvKD8/Pz24wUFBTp06JBeeeWVTveZMWOGhgwZooSEBL3yyisaNmyYbrjhBi1YsEBer7fLnEAgoEAg0H47FArp4MGDGjp0qDwej4PtAcDJxxijI0eOaOTIkYqJic5Hj5j3AOA+J/Pe0dtjDhw4oLa2NiUnJ3c4npycrJ07d3Z5n48//livvfaaZs2apbVr12r37t2aO3eugsGgSkpKurxPWVlZ+y+9AYD+av/+/Ro1alRUspn3ABA53Zn3rv9G1FAopOHDh+upp56S1+tVVlaWamtr9dBDDx13iBcXF8vv97ffPnz4sEaPHq09e/Zo0KBBrq01GAzq9ddf19/8zd9E7Fu70ciMVi577XuZ0crt63s9cuSIzjjjDFfnnRuY93bmste+lxmtXPYafk7mvaPSnpSUJK/Xq/r6+g7H6+vrlZKS0uV9RowYodjY2A7fGj333HNVV1en1tZWxcXFdbqPz+eTz+frdHzIkCFKTEx0smRHgsGgEhISNHTo0Ij+o4h0ZrRy2Wvfy4xWbl/f69FrR/PtIcz7vpPLXvteZrRy2Wv4OZn3jt4sGRcXp6ysLFVVVbUfC4VCqqqq0uTJk7u8z8UXX6zdu3crFAq1H/vwww81YsSILgc4ACD6mPcAYBfHn3Dy+/16+umn9W//9m/64IMPdNttt6m5uVmFhYWSpNmzZ6u4uLj9/Ntuu00HDx7U/Pnz9eGHH+q3v/2tfvrTn2revHnh2wUAIOyY9wBgD8fvaZ85c6YaGxu1aNEi1dXVadKkSVq3bl37h5X27dvX4dOvaWlpWr9+vX74wx9q4sSJSk1N1fz587VgwYLw7QIAEHbMewCwR48+iFpUVKSioqIu/2zjxo2djk2ePFlvvvlmT6IAAFHEvAcAO0TnBwADAAAA6DZKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYLkB0V4A0BPnr/zI4T0yVLpmb7fO3HbjWY7XAwAA4CZeaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALNej0l5eXq709HTFx8crNzdXNTU1xz332Weflcfj6fAVHx/f4wUDACKHeQ8AdnBc2isqKuT3+1VSUqKtW7cqMzNT06dPV0NDw3Hvk5iYqM8++6z965NPPunVogEA7mPeA4A9HJf2pUuXas6cOSosLFRGRoaWL1+uhIQErVix4rj38Xg8SklJaf9KTk7u1aIBAO5j3gOAPRyV9tbWVm3ZskV5eXlfXSAmRnl5eaqurj7u/b744guNGTNGaWlpuuaaa7Rjx46erxgA4DrmPQDYZYCTkw8cOKC2trZOr5wkJydr586dXd7nnHPO0YoVKzRx4kQdPnxYDz/8sC666CLt2LFDo0aN6vI+gUBAgUCg/XZTU5MkKRgMKhgMOlmyI0ev7WaGDZnRyo3WXp0Kx/r60+PLXt3LiSbmfd/JZa99LzNauezVvZzu8BhjTHdP/vTTT5WamqrNmzdr8uTJ7cfvuusubdq0Sb///e+7tbhzzz1X119/ve69994uzyktLdXixYs7HV+9erUSEhK6u1z0YaVNGe5dO/F9164NdEdLS4tuuOEGHT58WImJiVFZA/MeANznZN47eqU9KSlJXq9X9fX1HY7X19crJSWlW9eIjY3V+eefr927dx/3nOLiYvn9/vbbTU1NSktL07Rp01x9AgsGg6qsrNTUqVMVGxvrWk60M6OVG87M0jV7w7OoLsyYMaPX1zjZH1/bc/v6Xo++2hxNzPu+k8te+15mtHLZa/g5mfeOSntcXJyysrJUVVWl/Px8SVIoFFJVVZWKioq6dY22tja99957JyxGPp9PPp+v0/HY2NiI/GVFKifamdHKjdZeuyuca+tPjy97De/1o4153/dy2Wvfy4xWLnsN7/W7y1FplyS/36+CggJlZ2crJydHy5YtU3NzswoLCyVJs2fPVmpqqsrKyiRJ99xzjy688EKdeeaZOnTokB566CF98sknuuWWW5xGAwAiiHkPAPZwXNpnzpypxsZGLVq0SHV1dZo0aZLWrVvX/mGlffv2KSbmqx9K8/nnn2vOnDmqq6vT6aefrqysLG3evFkZGe69JxkA0HvMewCwh+PSLklFRUXH/fboxo0bO9x+5JFH9Mgjj/QkBgAQZcx7ALCD41+uBAAAACCyKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlBkR7AQAAALY5f+VHDs7OUOmavd0+e9uNZzleD8Ar7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5XpU2svLy5Wenq74+Hjl5uaqpqamW/dbs2aNPB6P8vPzexILAIgw5j0A2MFxaa+oqJDf71dJSYm2bt2qzMxMTZ8+XQ0NDSe83969e/WjH/1Il156aY8XCwCIHOY9ANjDcWlfunSp5syZo8LCQmVkZGj58uVKSEjQihUrjnuftrY2zZo1S4sXL9bYsWN7tWAAQGQw7wHAHo5Ke2trq7Zs2aK8vLyvLhATo7y8PFVXVx/3fvfcc4+GDx+um2++uecrBQBEDPMeAOwywMnJBw4cUFtbm5KTkzscT05O1s6dO7u8zxtvvKF//dd/1fbt27udEwgEFAgE2m83NTVJkoLBoILBoJMlO3L02m5m2JAZrdxo7dWpcKyvPz2+7NW9nGhi3vedXPZqH55n7M+1cd47Ku1OHTlyRDfeeKOefvppJSUldft+ZWVlWrx4cafjGzZsUEJCQjiX2KXKykrXM2zIjFZueDIzwnCNrq1duzZs1zp5H9+TI7ev7rWlpcXV67uBeW9/Lnt1iucZmzKjlWvTvPcYY0x3T25tbVVCQoJeeOGFDj8RoKCgQIcOHdIrr7zS4fzt27fr/PPPl9frbT8WCoUk/eXbrLt27dK4ceM65XT1yktaWpoOHDigxMTEbm/OqWAwqMrKSk2dOlWxsbGu5UQ7M1q54czMWbM3PIvqQs116b2+xsn++Nqe29f32tTUpKSkJB0+fNjVmXcizPu+k8tee4bnGTsyo5Vr47x39Ep7XFycsrKyVFVV1T7EQ6GQqqqqVFRU1On88ePH67333utw7Mc//rGOHDmin//850pLS+syx+fzyefzdToeGxsbkb+sSOVEOzNaudHaa3eFc2396fFlr+G9frQx7/teLnu1B88zJ0+uTfPe8dtj/H6/CgoKlJ2drZycHC1btkzNzc0qLCyUJM2ePVupqakqKytTfHy8zjvvvA73Hzx4sCR1Og4AsAvzHgDs4bi0z5w5U42NjVq0aJHq6uo0adIkrVu3rv3DSvv27VNMDL9oFQBOdsx7ALBHjz6IWlRU1OW3RyVp48aNJ7zvs88+25NIAEAUMO8BwA68RAIAAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWK5Hpb28vFzp6emKj49Xbm6uampqjnvuiy++qOzsbA0ePFinnHKKJk2apJUrV/Z4wQCAyGHeA4AdHJf2iooK+f1+lZSUaOvWrcrMzNT06dPV0NDQ5flDhgzR3Xffrerqar377rsqLCxUYWGh1q9f3+vFAwDcw7wHAHs4Lu1Lly7VnDlzVFhYqIyMDC1fvlwJCQlasWJFl+dffvnl+vu//3ude+65GjdunObPn6+JEyfqjTfe6PXiAQDuYd4DgD0GODm5tbVVW7ZsUXFxcfuxmJgY5eXlqbq6+mvvb4zRa6+9pl27dumBBx447nmBQECBQKD9dlNTkyQpGAwqGAw6WbIjR6/tZoYNmdHKjdZenQrH+vrT48te3cuJJuZ938llr/bhecb+XBvnvccYY7p78qeffqrU1FRt3rxZkydPbj9+1113adOmTfr973/f5f0OHz6s1NRUBQIBeb1ePf7447rpppuOm1NaWqrFixd3Or569WolJCR0d7now0qbMty7duL7rl0b6I6WlhbdcMMNOnz4sBITE6OyBuY9+jueZxAJTua9o1fae2rQoEHavn27vvjiC1VVVcnv92vs2LG6/PLLuzy/uLhYfr+//XZTU5PS0tI0bdo0V5/AgsGgKisrNXXqVMXGxrqWE+3MaOWGM7N0zd7wLKoLM2bM6PU1TvbH1/bcvr7Xo682n4yY9/blstee4XnGjsxo5do47x2V9qSkJHm9XtXX13c4Xl9fr5SUlOPeLyYmRmeeeaYkadKkSfrggw9UVlZ23CHu8/nk8/k6HY+NjY3IX1akcqKdGa3caO21u8K5tv70+LLX8F4/2pj3fS+XvdqD55mTJ9emee/og6hxcXHKyspSVVVV+7FQKKSqqqoO3z79OqFQqMN7GAEAdmHeA4BdHL89xu/3q6CgQNnZ2crJydGyZcvU3NyswsJCSdLs2bOVmpqqsrIySVJZWZmys7M1btw4BQIBrV27VitXrtQTTzwR3p0AAMKKeQ8A9nBc2mfOnKnGxkYtWrRIdXV1mjRpktatW6fk5GRJ0r59+xQT89UL+M3NzZo7d67+93//VwMHDtT48eO1atUqzZw5M3y7AACEHfMeAOzRow+iFhUVqaioqMs/27hxY4fb9913n+67776exAAAoox5DwB2cPzLlQAAAABEFqUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwXI9Ke3l5udLT0xUfH6/c3FzV1NQc99ynn35al156qU4//XSdfvrpysvLO+H5AAB7MO8BwA6OS3tFRYX8fr9KSkq0detWZWZmavr06WpoaOjy/I0bN+r666/X66+/rurqaqWlpWnatGmqra3t9eIBAO5h3gOAPRyX9qVLl2rOnDkqLCxURkaGli9froSEBK1YsaLL85977jnNnTtXkyZN0vjx4/WLX/xCoVBIVVVVvV48AMA9zHsAsIej0t7a2qotW7YoLy/vqwvExCgvL0/V1dXdukZLS4uCwaCGDBnibKUAgIhh3gOAXQY4OfnAgQNqa2tTcnJyh+PJycnauXNnt66xYMECjRw5ssMTwbECgYACgUD77aamJklSMBhUMBh0smRHjl7bzQwbMqOVG629OhWO9fWnx5e9upcTTcz7vpPLXu3D84z9uTbOe0elvbeWLFmiNWvWaOPGjYqPjz/ueWVlZVq8eHGn4xs2bFBCQoKbS5QkVVZWup5hQ2a0csOTmRGGa3Rt7dq1YbvWyfv4nhy5fXWvLS0trl4/Epj39uWyV6d4nrEpM1q5Ns17R6U9KSlJXq9X9fX1HY7X19crJSXlhPd9+OGHtWTJEv3ud7/TxIkTT3hucXGx/H5/++2mpqb2DzQlJiY6WbIjwWBQlZWVmjp1qmJjY13LiXZmtHLDmVm6Zm94FtWFGTNm9PoaJ/vja3tuX9/r0Vebo4l533dy2WvP8DxjR2a0cm2c945Ke1xcnLKyslRVVaX8/HxJav+QUVFR0XHv9+CDD+r+++/X+vXrlZ2d/bU5Pp9PPp+v0/HY2NiI/GVFKifamdHKjdZeuyuca+tPjy97De/1o4153/dy2as9eJ45eXJtmveO3x7j9/tVUFCg7Oxs5eTkaNmyZWpublZhYaEkafbs2UpNTVVZWZkk6YEHHtCiRYu0evVqpaenq66uTpJ06qmn6tRTT3UaDwCIEOY9ANjDcWmfOXOmGhsbtWjRItXV1WnSpElat25d+4eV9u3bp5iYr34ozRNPPKHW1lZ973vf63CdkpISlZaW9m71AADXMO8BwB49+iBqUVHRcb89unHjxg639+7d25MIAIAFmPcAYAfHv1wJAAAAQGRR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMv1qLSXl5crPT1d8fHxys3NVU1NzXHP3bFjh7773e8qPT1dHo9Hy5Yt6+laAQARxrwHADs4Lu0VFRXy+/0qKSnR1q1blZmZqenTp6uhoaHL81taWjR27FgtWbJEKSkpvV4wACAymPcAYA/HpX3p0qWaM2eOCgsLlZGRoeXLlyshIUErVqzo8vwLLrhADz30kK677jr5fL5eLxgAEBnMewCwh6PS3traqi1btigvL++rC8TEKC8vT9XV1WFfHAAgOpj3AGCXAU5OPnDggNra2pScnNzheHJysnbu3Bm2RQUCAQUCgfbbTU1NkqRgMKhgMBi2nGMdvbabGTZkRis3Wnt1Khzr60+PL3t1LyeamPd9J5e92ofnGftzbZz3jkp7pJSVlWnx4sWdjm/YsEEJCQmu51dWVrqeYUNmtHLDk5kRhmt0be3atWG71sn7+J4cuX11ry0tLa5e3yb9cd5HK/dk3Wtpk9N5n6HSX9d2//qJ7x/3Om453vNM9PbqzMn6b8nGTCfz3lFpT0pKktfrVX19fYfj9fX1Yf3QUXFxsfx+f/vtpqYmpaWladq0aUpMTAxbzrGCwaAqKys1depUxcbGupYT7cxo5YYzs3TN3vAsqgszZszo9TVO9sfX9ty+vtejrzZHE/O+7+Se7Ht1c95Lx5/50XieidZeu+tk/7dkY6aTee+otMfFxSkrK0tVVVXKz8+XJIVCIVVVVamoqMjRIk/E5/N1+SGm2NjYiPxlRSon2pnRyo3WXrsrnGvrT48vew3v9aONed/3cvvTXp2I1mMSDeHK7U//lmya947fHuP3+1VQUKDs7Gzl5ORo2bJlam5uVmFhoSRp9uzZSk1NVVlZmaS/fJjp/fffb//ftbW12r59u0499VSdeeaZTuMBABHCvAcAezgu7TNnzlRjY6MWLVqkuro6TZo0SevWrWv/sNK+ffsUE/PVD6X59NNPdf7557fffvjhh/Xwww9rypQp2rhxY+93AABwBfMeAOzRow+iFhUVHffbo8cO5vT0dBljehIDAIgy5j0A2MHxL1cCAAAAEFmUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMByHmOMifYivk5TU5NOO+00HT58WImJiY7ue/7Kj1xa1V9su/GsiOf2l8xo5bLX6Oy1Pz2+X6c3M+9k19u989+Le5lu59r0+Lqda9NeeXzdzz0RJzOPV9oBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMv1qLSXl5crPT1d8fHxys3NVU1NzQnP//d//3eNHz9e8fHx+sY3vqG1a9f2aLEAgMhi3gOAHRyX9oqKCvn9fpWUlGjr1q3KzMzU9OnT1dDQ0OX5mzdv1vXXX6+bb75Z27ZtU35+vvLz8/WHP/yh14sHALiHeQ8A9nBc2pcuXao5c+aosLBQGRkZWr58uRISErRixYouz//5z3+ub33rW7rzzjt17rnn6t5779U3v/lNPfbYY71ePADAPcx7ALDHACcnt7a2asuWLSouLm4/FhMTo7y8PFVXV3d5n+rqavn9/g7Hpk+frpdffvm4OYFAQIFAoP324cOHJUkHDx5UMBh0smS1/fkLR+c79ac//Sniuf0lM1q57DU6e+1Pj+/XOXLkiCTJGBPO5ThyMs57if9e3Mx0O9emx9ftXJv2yuPrfu6JOJr3xoHa2lojyWzevLnD8TvvvNPk5OR0eZ/Y2FizevXqDsfKy8vN8OHDj5tTUlJiJPHFF1989euv/fv3OxnRYcW854svvviK3Fd35r2jV9ojpbi4uMOrNaFQSAcPHtTQoUPl8Xhcy21qalJaWpr279+vxMRE13KinRmtXPba9zKjldvX92qM0ZEjRzRy5EjXMmzRn+Z9tHLZa9/LjFYuew0/J/PeUWlPSkqS1+tVfX19h+P19fVKSUnp8j4pKSmOzpckn88nn8/X4djgwYOdLLVXEhMTI/qPMVqZ0cplr30vM1q5fXmvp512mqvX/zrM+76Xy177Xma0ctlreHV33jv6IGpcXJyysrJUVVXVfiwUCqmqqkqTJ0/u8j6TJ0/ucL4kVVZWHvd8AED0Me8BwC6O3x7j9/tVUFCg7Oxs5eTkaNmyZWpublZhYaEkafbs2UpNTVVZWZkkaf78+ZoyZYp+9rOf6aqrrtKaNWv09ttv66mnngrvTgAAYcW8BwB7OC7tM2fOVGNjoxYtWqS6ujpNmjRJ69atU3JysiRp3759ion56gX8iy66SKtXr9aPf/xj/fM//7POOussvfzyyzrvvPPCt4sw8fl8Kikp6fSt2r6WGa1c9tr3MqOV25/2Gk3M+76Ry177Xma0ctlrdHmMieLPFAMAAADwtRz/ciUAAAAAkUVpBwAAACxHaQcAAAAsR2kHAAAALEdp///Ky8uVnp6u+Ph45ebmqqamxtW8//qv/9K3v/1tjRw5Uh6PRy+//LKreZJUVlamCy64QIMGDdLw4cOVn5+vXbt2uZ77xBNPaOLEie2/oGDy5Ml69dVXXc/9a0uWLJHH49Edd9zhak5paak8Hk+Hr/Hjx7uaKUm1tbX6wQ9+oKFDh2rgwIH6xje+obffftvVzPT09E579Xg8mjdvnmuZbW1t+slPfqIzzjhDAwcO1Lhx43TvvffK7c/THzlyRHfccYfGjBmjgQMH6qKLLtJbb73laibcxcx3B/OeeR8uzPvOKO2SKioq5Pf7VVJSoq1btyozM1PTp09XQ0ODa5nNzc3KzMxUeXm5axnH2rRpk+bNm6c333xTlZWVCgaDmjZtmpqbm13NHTVqlJYsWaItW7bo7bff1t/+7d/qmmuu0Y4dO1zNPeqtt97Sk08+qYkTJ0Ykb8KECfrss8/av9544w1X8z7//HNdfPHFio2N1auvvqr3339fP/vZz3T66ae7mvvWW2912GdlZaUk6fvf/75rmQ888ICeeOIJPfbYY/rggw/0wAMP6MEHH9Sjjz7qWqYk3XLLLaqsrNTKlSv13nvvadq0acrLy1Ntba2ruXAHM9+9mc+8Z96HC/O+CwYmJyfHzJs3r/12W1ubGTlypCkrK4tIviTz0ksvRSTrrzU0NBhJZtOmTRHPPv30080vfvEL13OOHDlizjrrLFNZWWmmTJli5s+f72peSUmJyczMdDXjWAsWLDCXXHJJRDO7Mn/+fDNu3DgTCoVcy7jqqqvMTTfd1OHYd77zHTNr1izXMltaWozX6zW/+c1vOhz/5je/ae6++27XcuEeZn5kZz7zPnyY9/173vf7V9pbW1u1ZcsW5eXltR+LiYlRXl6eqquro7gy9x0+fFiSNGTIkIhltrW1ac2aNWpubo7IrzafN2+errrqqg5/v2776KOPNHLkSI0dO1azZs3Svn37XM37j//4D2VnZ+v73/++hg8frvPPP19PP/20q5nHam1t1apVq3TTTTfJ4/G4lnPRRRepqqpKH374oSTpnXfe0RtvvKErr7zStcwvv/xSbW1tio+P73B84MCBrr+qhvBj5kdu5jPvw49538/nfbT/X0O01dbWGklm8+bNHY7feeedJicnJyJrUBRedWlrazNXXXWVufjiiyOS9+6775pTTjnFeL1ec9ppp5nf/va3rmc+//zz5rzzzjN//vOfjTEmIq+8rF271vzqV78y77zzjlm3bp2ZPHmyGT16tGlqanIt0+fzGZ/PZ4qLi83WrVvNk08+aeLj482zzz7rWuaxKioqjNfrNbW1ta7mtLW1mQULFhiPx2MGDBhgPB6P+elPf+pqpjHGTJ482UyZMsXU1taaL7/80qxcudLExMSYs88+2/VshBcz3/2Zz7xn3ocD874zSns/HeD/+I//aMaMGWP2798fkbxAIGA++ugj8/bbb5uFCxeapKQks2PHDtfy9u3bZ4YPH27eeeed9mORGOLH+vzzz01iYqKr3xqOjY01kydP7nDs9ttvNxdeeKFrmceaNm2a+bu/+zvXc55//nkzatQo8/zzz5t3333X/PKXvzRDhgxx/Qlr9+7d5rLLLjOSjNfrNRdccIGZNWuWGT9+vKu5CD9mvvszn3nPvA8H5n1n/b60BwIB4/V6Ow3Q2bNnm6uvvjoia4j0AJ83b54ZNWqU+fjjjyOWeawrrrjC3Hrrra5d/6WXXmr/D+7olyTj8XiM1+s1X375pWvZx8rOzjYLFy507fqjR482N998c4djjz/+uBk5cqRrmX9t7969JiYmxrz88suuZ40aNco89thjHY7de++95pxzznE92xhjvvjiC/Ppp58aY4y59tprzYwZMyKSi/Bh5kce8z58mPf9e973+/e0x8XFKSsrS1VVVe3HQqGQqqqqIvIevEgyxqioqEgvvfSSXnvtNZ1xxhlRW0soFFIgEHDt+ldccYXee+89bd++vf0rOztbs2bN0vbt2+X1el3L/mtffPGF/vjHP2rEiBGuZVx88cWdfozbhx9+qDFjxriW+deeeeYZDR8+XFdddZXrWS0tLYqJ6Ti2vF6vQqGQ69mSdMopp2jEiBH6/PPPtX79el1zzTURyUX4MPMjj3kfPsz7fj7vo/3/GmywZs0a4/P5zLPPPmvef/99c+utt5rBgweburo61zKPHDlitm3bZrZt22YkmaVLl5pt27aZTz75xLXM2267zZx22mlm48aN5rPPPmv/amlpcS3TGGMWLlxoNm3aZPbs2WPeffdds3DhQuPxeMyGDRtczT1WJL5d+k//9E9m48aNZs+ePeZ//ud/TF5enklKSjINDQ2uZdbU1JgBAwaY+++/33z00UfmueeeMwkJCWbVqlWuZR7V1tZmRo8ebRYsWOB6ljHGFBQUmNTUVPOb3/zG7Nmzx7z44osmKSnJ3HXXXa7mrlu3zrz66qvm448/Nhs2bDCZmZkmNzfXtLa2upoLdzDz3Zv5zHvmfbgw7zujtP9/jz76qBk9erSJi4szOTk55s0333Q17/XXXzeSOn0VFBS4ltlVniTzzDPPuJZpjDE33XSTGTNmjImLizPDhg0zV1xxRcQHuDGRGeIzZ840I0aMMHFxcSY1NdXMnDnT7N6929VMY4z5z//8T3PeeecZn89nxo8fb5566inXM40xZv369UaS2bVrV0TympqazPz5883o0aNNfHy8GTt2rLn77rtNIBBwNbeiosKMHTvWxMXFmZSUFDNv3jxz6NAhVzPhLma+O5j3zPtwYd535jHG5V8tBQAAAKBX+v172gEAAADbUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMv9Pxe18cIAL5KKAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from filterpy.discrete_bayes import predict\n",
    "\n",
    "belief = [.05, .05, .05, .05, .55, .05, .05, .05, .05, .05]\n",
    "prior = predict(belief, offset=1, kernel=[.1, .8, .1])\n",
    "# prior = predict_move_convolution(belief, offset=1, kernel=[.1, .8, .1])\n",
    "book_plots.plot_belief_vs_prior(belief, prior, ylim=(0,0.6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b66b0e9a",
   "metadata": {},
   "source": [
    "除了中间的元素外，所有元素都没有改变。 位置 4 和 6 中的值应为\n",
    "$$(0.1 \\times 0.05)+ (0.8 \\times 0.05) + (0.1 \\times 0.55) = 0.1$$\n",
    "\n",
    "位置 5 应该是 $$(0.1 \\times 0.05) + (0.8 \\times 0.55)+ (0.1 \\times 0.05) = 0.45$$\n",
    "\n",
    "让我们确保它为大于 1 的运动和非对称内核正确移动位置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "id": "cec5dc7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prior = predict(belief, offset=3, kernel=[.05, .05, .6, .2, .1])\n",
    "book_plots.plot_belief_vs_prior(belief, prior, ylim=(0,0.6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec45ff54",
   "metadata": {},
   "source": [
    "这个位置被正确地移动了3个位置，我们赋予了overshoot的likelihood更多的权重，因此这看起来是正确的。\n",
    "确保你已经理解我们做的事情。我们正在预测小狗的移动位置，并对（信念）概率分布进行了卷积操作以获得先验信息。\n",
    "\n",
    "如果我们没有使用概率，那么我们会使用之前所给出的等式：\n",
    "$$ \\bar x_{k+1} = f_x(\\bullet) + x_k$$\n",
    "\n",
    "在先验中，我们预测狗小狗将在哪里，为小狗移动的距离加上它当前的位置。当小狗在（位置）10处，它移动了5米，因此他在15米处。这是很简单的事情。（使用卷积来表示状态转移方程）但是当我们使用概率模型到此处时，我们的方程为：\n",
    "$$ \\bar x_{k+1} = x_k \\ast f_x(\\bullet) $$\n",
    "\n",
    "我们将  当前的概率位置估计值（ *the current probabilistic position estimate*  ）  与我们认为的狗移动了多少的概率估计值（ *a probabilistic estimate of how much we think the dog moved*  ）  进行卷积，这是同一个概念，但是数学上略有不同，粗体x定义了一个数字数组。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1db2ed2e",
   "metadata": {},
   "source": [
    "##Section2.8 Integrating Measurements and Movement Updates 集成测量并进行运动更新\n",
    "\n",
    "在预测过程中丢失信息的问题可能会让我们的系统看起来好像很快就会变成一无所知。但是，每次预测之后都会进行update，即我们将测量结果合并到估计值中。update提高了我们的知识。update步骤的输出被输入到下一个预测中。预测降低了我们的确定性。这被传递到另一个更新（这个确定性在测量信息增加后进行提高），其中确定性再次增加。\n",
    "\n",
    "让我们直观地思考一下。考虑一个简单的案例 - 您正在跟踪一只坐着不动的狗。在每次预测期间，您都预测他不会移动。你的滤波器很快*收敛*他的位置的准确估计。然后厨房里的微波炉打开了，他像一道闪电般奔去。你不知道这一点，所以在下一个预测中你预测他在同一个位置。但测量结果讲述了一个不同的故事。当您合并测量值时，您的信念将沿着走廊分散，通向厨房。在每个epoch（循环）中，您认为他坐着不动的信念会变小，而您认为他以惊人的速度进入厨房的信念会增加。\n",
    "\n",
    "这就是直觉告诉我们的。数学告诉我们什么？\n",
    "\n",
    "我们已经对更新和预测步骤进行了编程。我们需要做的就是将一个的结果输入另一个，我们将实现一个狗追踪器！！！让我们看看它的表现如何。我们将输入测量值，就好像狗从位置 0 开始并在每个时期向右移动一个位置。就像在现实世界的应用程序中一样，我们将从不知道他的位置开始，为所有位置分配相等的概率。（这里需要记住，移动的测量用于预测，而位置的测量这里是状态）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "349af174",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3. 3. 1. 1. 1. 1. 1. 1. 3. 1.]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from filterpy.discrete_bayes import update\n",
    "\n",
    "hallway = np.array([1, 1, 0, 0, 0, 0, 0, 0, 1, 0])\n",
    "prior = np.array([.1] * 10)\n",
    "likelihood = lh_hallway(hallway, z=1, z_prob=.75)\n",
    "print(likelihood)\n",
    "posterior = update(likelihood, prior)\n",
    "book_plots.plot_prior_vs_posterior(prior, posterior, ylim=(0,.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "465aebd5",
   "metadata": {},
   "source": [
    "第一次更新后，我们为每个门位置分配了高概率，为每个墙位置分配了低概率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "31430574",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "kernel = (.1, .8, .1)\n",
    "prior = predict(posterior, 1, kernel)\n",
    "book_plots.plot_prior_vs_posterior(prior, posterior, True, ylim=(0,.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc91a3c0",
   "metadata": {},
   "source": [
    "预测步骤将这些概率向右移动，使它们模糊了一点。 现在让我们看看在下一个意义上会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "35fb0da2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu0AAAF2CAYAAADa96Z6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAs+UlEQVR4nO3de3RU5b3/8c8kJBMiRC6BBMIlgFSISFAiCF7AQyQKVrG1chSFFZSuI6QL13gj2pKk2AY9SmklXLRFLIrg6RFP6wVNo3CWJYjc1INCwYJYkACKJCY1iZnn90d/TB2SYHaYPfMweb/WylrOZs/+PE80Xz5O5uIxxhgBAAAAsFZMpBcAAAAA4PQo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtQDM8Ho8KCwsjvQwAwFlixYoV8ng82r9/f6SXgihEaQcAAG1CTU2NCgsLtX79+kgvBXDMY4wxkV4EYKOvv/5a7dq1U7t27SK9FABACBw7dkzdunVTQUGBK79JbWhoUH19vbxerzweT8ivj7aNR9qBb/H7/fr6668lSQkJCSEr7NXV1SG5DgDAPidnfGxsrBISEkJW2GtqakJyHUQHSjuiUmFhoTwej3bt2qWbb75ZSUlJ6tq1q2bPnh0o5dI/n7eel5en5557ThdccIG8Xq/WrVsX+LNTH4nZvn27rr32WiUlJalDhw4aN26cNm3aFHTOyec0btiwQTNnzlT37t3Vq1cv1/cMAGebls7qb775RvPmzdOAAQPk9XqVnp6uBx98ULW1tUHX27Jli3JycpScnKz27durX79+mj59uiRp//796tatmySpqKhIHo+n0ZzftWuXbrrpJnXp0kUJCQnKysrSH//4x6CM08345p7Tvnjx4sDfMT179tSsWbP05ZdfBp0zduxYDRkyRFu3btWVV16pxMREPfjgg2fy7UWU4ff+iGo333yz0tPTVVxcrE2bNuk3v/mNjh8/rt///veBc95880298MILysvLU3JystLT05u81s6dO3XFFVcoKSlJ999/v+Li4rRs2TKNHTtWGzZs0MiRI4POnzlzprp166a5c+fySDsAnMZ3zeo777xTzzzzjG666Sbdc889euedd1RcXKyPPvpIa9eulSQdOXJE48ePV7du3TRnzhx16tRJ+/fv14svvihJ6tatm5YsWaK77rpLN954o37wgx9IkoYOHSrpnzP+sssuU1pamubMmaNzzjlHL7zwgiZNmqT//u//1o033hi05pbO+MLCQhUVFSk7O1t33XWXdu/erSVLlujdd9/VX/7yF8XFxQXO/fzzz3Xttdfq3//933XbbbcpJSUldN9knP0MEIUKCgqMJHP99dcHHZ85c6aRZN577z1jjDGSTExMjNm5c2eja0gyBQUFgduTJk0y8fHx5uOPPw4cO3TokOnYsaO58sorA8eefvppI8lcfvnl5ptvvgnxzgAgerRkVu/YscNIMnfeeWfQOffee6+RZN58801jjDFr1641ksy7777bbN7Ro0cbzfaTxo0bZy688ELz9ddfB475/X4zevRoM3DgwMCx0834k3+2b98+Y4wxR44cMfHx8Wb8+PGmoaEhcN6iRYuMJLN8+fLAsTFjxhhJZunSpc2uH20bT49BVJs1a1bQ7Z/85CeSpFdffTVwbMyYMcrIyDjtdRoaGvTGG29o0qRJ6t+/f+B4jx49dOutt+rtt99WZWVl0H1mzJih2NjYM90CAES9083qk/Pa5/MFnXPPPfdIkl555RVJUqdOnSRJL7/8surr6x3lf/HFF3rzzTd18803q6qqSseOHdOxY8f0+eefKycnR3v27NHBgweD7tOSGf/nP/9ZdXV1uvvuuxUT86/KNWPGDCUlJQXWfpLX61Vubq6jtaPtoLQjqg0cODDo9oABAxQTExP0fMN+/fp953WOHj2qmpoanX/++Y3+bPDgwfL7/fr000+DjrfkugCA08/qTz75RDExMTrvvPOCzklNTVWnTp30ySefSPrnAzA//OEPVVRUpOTkZN1www16+umnGz3vvSl79+6VMUY/+9nP1K1bt6CvgoICSf98+s23tWTGn1zbqX93xMfHq3///oE/PyktLU3x8fHfeV20TTynHW1KU6/ob9++vStZbl0XAKJdU7P6u96RxePx6A9/+IM2bdqkP/3pT3r99dc1ffp0Pf7449q0aZM6dOjQ7H39fr8k6d5771VOTk6T55z6Pw1uzHj+3sDpUNoR1fbs2RP0aMjevXvl9/ubfbFpc7p166bExETt3r270Z/t2rVLMTEx6t2795kuFwDapNPNamOM/H6/9uzZo8GDBwfOqaio0Jdffqm+ffsGXevSSy/VpZdeql/84hdatWqVpkyZotWrV+vOO+9stviffNpjXFycsrOzQ7avk2vbvXt30FMr6+rqtG/fvpBmIfrx9BhEtZKSkqDbTzzxhCTp2muvdXSd2NhYjR8/Xv/zP/8T9NSaiooKrVq1SpdffrmSkpLOeL0A0BadblZPmDBBkrRw4cKgcxYsWCBJmjhxoiTp+PHjMqd8XuSwYcMkKfAUmcTERElq9HaL3bt319ixY7Vs2TJ99tlnjdZ39OhRhzv6p+zsbMXHx+s3v/lN0Np+97vf6cSJE4G1Ay3BI+2Iavv27dP111+va665RuXl5Xr22Wd16623KjMz0/G1Hn74YZWWluryyy/XzJkz1a5dOy1btky1tbV69NFHXVg9ALQN3zWrp02bpieffFJffvmlxowZo82bN+uZZ57RpEmTdNVVV0mSnnnmGS1evFg33nijBgwYoKqqKj311FNKSkoKFP/27dsrIyNDa9as0fe+9z116dJFQ4YM0ZAhQ1RSUqLLL79cF154oWbMmKH+/furoqJC5eXl+vvf/6733nvP8b66deum/Px8FRUV6ZprrtH111+v3bt3a/Hixbrkkkt02223he6biOgX2TevAdxx8m3EPvzwQ3PTTTeZjh07ms6dO5u8vDzzj3/8I3CeJDNr1qwmr6Em3hZs27ZtJicnx3To0MEkJiaaq666ymzcuDHonJNv+XW6tx0DALR8VtfX15uioiLTr18/ExcXZ3r37m3y8/OD3p5x27Zt5pZbbjF9+vQxXq/XdO/e3Vx33XVmy5YtQZkbN240w4cPN/Hx8Y3m/Mcff2ymTp1qUlNTTVxcnElLSzPXXXed+cMf/hA453Qz/tS3fDxp0aJFZtCgQSYuLs6kpKSYu+66yxw/fjzonDFjxpgLLrigFd9FtBUeY075XRIQBU5+mMXRo0eVnJwc6eUAAJrArAZajue0AwAAAJajtAMAAACWo7QDAAAAlmtVaS8pKVF6eroSEhI0cuRIbd68udlzV6xYIY/HE/SVkJDQ6gUDLVFYWChjDM+RBM4Q8x5uYlYDLee4tK9Zs0Y+n08FBQXatm2bMjMzlZOT0+jjfb8tKSlJn332WeDr1I/tBQDYh3kPAPZwXNoXLFigGTNmKDc3VxkZGVq6dKkSExO1fPnyZu/j8XiUmpoa+EpJSTmjRQMA3Me8BwB7OPpwpbq6Om3dulX5+fmBYzExMcrOzlZ5eXmz9/vqq6/Ut29f+f1+XXzxxfrlL3+pCy64oNnza2trA59eJkl+v19ffPGFunbt2uxHEANAtDDGqKqqSj179lRMTGReesS8BwD3OZn3jkr7sWPH1NDQ0OiRk5SUFO3atavJ+5x//vlavny5hg4dqhMnTuixxx7T6NGjtXPnTvXq1avJ+xQXF6uoqMjJ0gAg6nz66afNzkm3Me8BIHxaMu8dlfbWGDVqlEaNGhW4PXr0aA0ePFjLli3TvHnzmrxPfn6+fD5f4PaJEyfUp08f7du3Tx07dnRtrfX19Xrrrbd01VVXKS4uzrWcSGdGKpe9Rl9mpHKjfa9VVVXq16+fq/PODcx7O3PZa/RlRiqXvYaek3nvqLQnJycrNjZWFRUVQccrKiqUmpraomvExcXpoosu0t69e5s9x+v1yuv1NjrepUsXJSUlOVmyI/X19UpMTFTXrl3D+h9FuDMjlcteoy8zUrnRvteT147k00OY99GTy16jLzNSuew19JzMe0dPloyPj9fw4cNVVlYWOOb3+1VWVhb06MrpNDQ06IMPPlCPHj2cRAMAwoh5DwB2cfz0GJ/Pp2nTpikrK0sjRozQwoULVV1drdzcXEnS1KlTlZaWpuLiYknSz3/+c1166aU677zz9OWXX+o///M/9cknn+jOO+8M7U4AACHFvAcAezgu7ZMnT9bRo0c1d+5cHT58WMOGDdO6desCL1Y6cOBA0Ktfjx8/rhkzZujw4cPq3Lmzhg8fro0bNyojIyN0uwAAhBzzHgDs0aoXoubl5SkvL6/JP1u/fn3Q7V/96lf61a9+1ZoYAECEMe8BwA6ReQNgAAAAAC1GaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAsR2kHAAAALEdpBwAAACxHaQcAAAAs16rSXlJSovT0dCUkJGjkyJHavHlzi+63evVqeTweTZo0qTWxAIAwY94DgB0cl/Y1a9bI5/OpoKBA27ZtU2ZmpnJycnTkyJHT3m///v269957dcUVV7R6sQCA8GHeA4A9HJf2BQsWaMaMGcrNzVVGRoaWLl2qxMRELV++vNn7NDQ0aMqUKSoqKlL//v3PaMEAgPBg3gOAPRyV9rq6Om3dulXZ2dn/ukBMjLKzs1VeXt7s/X7+85+re/fuuuOOO1q/UgBA2DDvAcAu7ZycfOzYMTU0NCglJSXoeEpKinbt2tXkfd5++2397ne/044dO1qcU1tbq9ra2sDtyspKSVJ9fb3q6+udLNmRk9d2M8OGzEjlstfoy4xUbrTvNdz7agrzPnpy2Wv0ZUYql726l9MSjkq7U1VVVbr99tv11FNPKTk5ucX3Ky4uVlFRUaPjb7zxhhITE0O5xCaVlpa6nmFDZqRy2Wv0ZUYqN1r3WlNT4+r13cC8tz+XvUZfZqRy2WvoOJn3jkp7cnKyYmNjVVFREXS8oqJCqampjc7/+OOPtX//fn3/+98PHPP7/f8MbtdOu3fv1oABAxrdLz8/Xz6fL3C7srJSvXv31vjx45WUlORkyY7U19ertLRUV199teLi4lzLiXRmpHLZa/RlRio32vd68tHmSGLeR08ue42+zEjlstfQczLvHZX2+Ph4DR8+XGVlZYG38fL7/SorK1NeXl6j8wcNGqQPPvgg6NhPf/pTVVVV6de//rV69+7dZI7X65XX6210PC4uLiz/ssKVE+nMSOWy1+jLjFRutO41Ens6FfM++nLZa/RlRiqXvYb2+i3l+OkxPp9P06ZNU1ZWlkaMGKGFCxequrpaubm5kqSpU6cqLS1NxcXFSkhI0JAhQ4Lu36lTJ0lqdBwAYBfmPQDYw3Fpnzx5so4ePaq5c+fq8OHDGjZsmNatWxd4sdKBAwcUE8MHrQLA2Y55DwD2aNULUfPy8pr89agkrV+//rT3XbFiRWsiAQARwLwHADvwEAkAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYLl2kV4AAABns4tW7nF4jwwVrt7f4rO33z7Q4fUBRCMeaQcAAAAsR2kHAAAALEdpBwAAACzXqtJeUlKi9PR0JSQkaOTIkdq8eXOz57744ovKyspSp06ddM4552jYsGFauXJlqxcMAAgf5j0A2MFxaV+zZo18Pp8KCgq0bds2ZWZmKicnR0eOHGny/C5duuihhx5SeXm53n//feXm5io3N1evv/76GS8eAOAe5j0A2MNxaV+wYIFmzJih3NxcZWRkaOnSpUpMTNTy5cubPH/s2LG68cYbNXjwYA0YMECzZ8/W0KFD9fbbb5/x4gEA7mHeA4A9HL3lY11dnbZu3ar8/PzAsZiYGGVnZ6u8vPw772+M0Ztvvqndu3frkUceafa82tpa1dbWBm5XVlZKkurr61VfX+9kyY6cvLabGTZkRiqXvUZfZqRyo32v4d5XU5j39jjTNUb7z0tbzIxULnt1L6clPMYY09KTDx06pLS0NG3cuFGjRo0KHL///vu1YcMGvfPOO03e78SJE0pLS1Ntba1iY2O1ePFiTZ8+vdmcwsJCFRUVNTq+atUqJSYmtnS5AHBWqqmp0a233qoTJ04oKSkpImtg3rdcYWWGu9dP+tDV6wOIHCfzPiwfrtSxY0ft2LFDX331lcrKyuTz+dS/f3+NHTu2yfPz8/Pl8/kCtysrK9W7d2+NHz/e1b/A6uvrVVpaqquvvlpxcXGu5UQ6M1K57DX6MiOVG+17Pflo89moLc57Jx+U1BoTJkw4o/tH+89LW8yMVC57DT0n895RaU9OTlZsbKwqKiqCjldUVCg1NbXZ+8XExOi8886TJA0bNkwfffSRiouLmx3iXq9XXq+30fG4uLiw/MsKV06kMyOVy16jLzNSudG610js6VTMe3uEan3R+vPSljMjlcteQ3v9lnL0QtT4+HgNHz5cZWVlgWN+v19lZWVBvz79Ln6/P+g5jAAAuzDvAcAujp8e4/P5NG3aNGVlZWnEiBFauHChqqurlZubK0maOnWq0tLSVFxcLEkqLi5WVlaWBgwYoNraWr366qtauXKllixZEtqdAABCinkPAPZwXNonT56so0ePau7cuTp8+LCGDRumdevWKSUlRZJ04MABxcT86wH86upqzZw5U3//+9/Vvn17DRo0SM8++6wmT54cul0AAEKOeQ8A9mjVC1Hz8vKUl5fX5J+tX78+6PbDDz+shx9+uDUxAIAIY94DgB0cf7gSAAAAgPCitAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlqO0AwAAAJajtAMAAACWo7QDAAAAlmtVaS8pKVF6eroSEhI0cuRIbd68udlzn3rqKV1xxRXq3LmzOnfurOzs7NOeDwCwB/MeAOzguLSvWbNGPp9PBQUF2rZtmzIzM5WTk6MjR440ef769et1yy236K233lJ5ebl69+6t8ePH6+DBg2e8eACAe5j3AGAPx6V9wYIFmjFjhnJzc5WRkaGlS5cqMTFRy5cvb/L85557TjNnztSwYcM0aNAg/fa3v5Xf71dZWdkZLx4A4B7mPQDYo52Tk+vq6rR161bl5+cHjsXExCg7O1vl5eUtukZNTY3q6+vVpUuXZs+pra1VbW1t4HZlZaUkqb6+XvX19U6W7MjJa7uZYUNmpHLZa/RlRio32vca7n01hXlvjzNdY7T/vLTFzEjlslf3clrCY4wxLT350KFDSktL08aNGzVq1KjA8fvvv18bNmzQO++8853XmDlzpl5//XXt3LlTCQkJTZ5TWFiooqKiRsdXrVqlxMTEli4XAM5KNTU1uvXWW3XixAklJSVFZA3M+5YrrMxw9/pJH7p6fQCR42TeO3qk/UzNnz9fq1ev1vr165sd4JKUn58vn88XuF1ZWRl4bqSbf4HV19ertLRUV199teLi4lzLiXRmpHLZa/RlRio32vd68tHms1lbmveFq/eHZlHNmDBhwhndP9p/XtpiZqRy2WvoOZn3jkp7cnKyYmNjVVFREXS8oqJCqampp73vY489pvnz5+vPf/6zhg4detpzvV6vvF5vo+NxcXFh+ZcVrpxIZ0Yql71GX2akcqN1r5HY06mY9/YI1fqi9eelLWdGKpe9hvb6LeXohajx8fEaPnx40IuKTr7I6Nu/Pj3Vo48+qnnz5mndunXKyspyEgkAiADmPQDYxfHTY3w+n6ZNm6asrCyNGDFCCxcuVHV1tXJzcyVJU6dOVVpamoqLiyVJjzzyiObOnatVq1YpPT1dhw8fliR16NBBHTp0COFWAAChxLwHAHs4Lu2TJ0/W0aNHNXfuXB0+fFjDhg3TunXrlJKSIkk6cOCAYmL+9QD+kiVLVFdXp5tuuinoOgUFBSosLDyz1QMAXMO8BwB7tOqFqHl5ecrLy2vyz9avXx90e//+/a2JAABYgHkPAHZw/OFKAAAAAMKL0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYjtIOAAAAWI7SDgAAAFiO0g4AAABYrlUfroTvdtHKPQ7OzlDh6v0tPnv77QNDkOkst7lMAAAAuI9H2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADLUdoBAAAAy1HaAQAAAMtR2gEAAADL8T7tANo0Pt8AAHA24JF2AAAAwHKUdgAAAMBylHYAAADAcjynHQAQNZy9RqHlr0+QeI0CgMjikXYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcu0ivQAAAAC0LRet3OPwHhkqXL2/RWduv32g4/WcDXikHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsFyrSntJSYnS09OVkJCgkSNHavPmzc2eu3PnTv3whz9Uenq6PB6PFi5c2Nq1AgDCjHkPAHZwXNrXrFkjn8+ngoICbdu2TZmZmcrJydGRI0eaPL+mpkb9+/fX/PnzlZqaesYLBgCEB/MeAOzRzukdFixYoBkzZig3N1eStHTpUr3yyitavny55syZ0+j8Sy65RJdccokkNfnnAAA7Me/tddHKPQ7vkaHC1ftbfPb22wc6vD4Atzl6pL2urk5bt25Vdnb2vy4QE6Ps7GyVl5eHfHEAgMhg3gOAXRw90n7s2DE1NDQoJSUl6HhKSop27doVskXV1taqtrY2cLuyslKSVF9fr/r6+pDlnOrktd3MCIVIrC8UmZH6/kYit61kRio32n9WbdhXtM/71ojUepj5ZNqSG+2zt6lruL1XJ9d3/PSYcCguLlZRUVGj42+88YYSExNdzy8tLQ3BVTJCcI2mvfrqqxZlOhea7+/ZkdtWMiOVe/b+rJ5eTU1NiFdir9DP++iavc3nRiKzdc7e2WB/ZqRyo3X2NsXt76+Tee+otCcnJys2NlYVFRVBxysqKkL6oqP8/Hz5fL7A7crKSvXu3Vvjx49XUlJSyHJOVV9fr9LSUl199dWKi4s7o2s5ee6gUxMmTLAm04lQfn9tz20rmZHKPdt/Vr/LyUebI+lsnffRNnuby41EplNn+2ywOTNSudE+e78tXN9fJ/PeUWmPj4/X8OHDVVZWpkmTJkmS/H6/ysrKlJeX52iRp+P1euX1ehsdj4uLC8t/mOHKaa1IrC2UmZH6/kYit61kRio3Wn9WbdhTW5n3TkRqPcx8Mm3LtfHn89uaW1urXsD93wdbfHZrXsDt5Pvo+OkxPp9P06ZNU1ZWlkaMGKGFCxequro68O4CU6dOVVpamoqLiyX988VMH374YeCfDx48qB07dqhDhw4677zznMYDAMKEeQ8A9nBc2idPnqyjR49q7ty5Onz4sIYNG6Z169YFXqx04MABxcT8601pDh06pIsuuihw+7HHHtNjjz2mMWPGaP369We+AwCAK5j3AGCPVr0QNS8vr9lfj546mNPT02WMaU0MACDCmPcAYAfHn4gKAAAAILysfMvHUOJT4wAAAHC245F2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHJR/z7tcBfvg49Q4b8lAACaxyPtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOUo7QAAAIDlKO0AAACA5SjtAAAAgOV4n3acldx8T+/m3s87Uu8j7iw3EpmhywUAAE3jkXYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcpR2AAAAwHKUdgAAAMBylHYAAADAcu0ivQAAAHB2uGjlHof3yFDh6v0tOnP77QMdrwdoS3ikHQAAALAcpR0AAACwHKUdAAAAsBzPaQcAANZy83n0UvPPpXeWG4nM0ORG6vsL53ikHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsBylHQAAALAcpR0AAACwHKUdAAAAsFyrSntJSYnS09OVkJCgkSNHavPmzac9/7/+6780aNAgJSQk6MILL9Srr77aqsUCAMKLeQ8AdnBc2tesWSOfz6eCggJt27ZNmZmZysnJ0ZEjR5o8f+PGjbrlllt0xx13aPv27Zo0aZImTZqk//u//zvjxQMA3MO8BwB7OC7tCxYs0IwZM5Sbm6uMjAwtXbpUiYmJWr58eZPn//rXv9Y111yj++67T4MHD9a8efN08cUXa9GiRWe8eACAe5j3AGCPdk5Orqur09atW5Wfnx84FhMTo+zsbJWXlzd5n/Lycvl8vqBjOTk5eumll5rNqa2tVW1tbeD2iRMnJElffPGF6uvrnSxZDf/4ytH5Tn3++edhz20rmZHKZa+R2Wtb+v5+l6qqKkmSMSaUy3HkbJz3Ej8vbma6nWvT99ftXJv2yvfX/dzTcTTvjQMHDx40kszGjRuDjt93331mxIgRTd4nLi7OrFq1KuhYSUmJ6d69e7M5BQUFRhJffPHFV5v++vTTT52M6JBi3vPFF198he+rJfPe0SPt4ZKfnx/0aI3f79cXX3yhrl27yuPxuJZbWVmp3r1769NPP1VSUpJrOZHOjFQue42+zEjlRvtejTGqqqpSz549XcuwRVua95HKZa/RlxmpXPYaek7mvaPSnpycrNjYWFVUVAQdr6ioUGpqapP3SU1NdXS+JHm9Xnm93qBjnTp1crLUM5KUlBTW/xgjlRmpXPYafZmRyo3mvZ577rmuXv+7MO+jL5e9Rl9mpHLZa2i1dN47eiFqfHy8hg8frrKyssAxv9+vsrIyjRo1qsn7jBo1Kuh8SSotLW32fABA5DHvAcAujp8e4/P5NG3aNGVlZWnEiBFauHChqqurlZubK0maOnWq0tLSVFxcLEmaPXu2xowZo8cff1wTJ07U6tWrtWXLFj355JOh3QkAIKSY9wBgD8elffLkyTp69Kjmzp2rw4cPa9iwYVq3bp1SUlIkSQcOHFBMzL8ewB89erRWrVqln/70p3rwwQc1cOBAvfTSSxoyZEjodhEiXq9XBQUFjX5VG22Zkcplr9GXGanctrTXSGLeR0cue42+zEjlstfI8hgTwfcUAwAAAPCdHH+4EgAAAIDworQDAAAAlqO0AwAAAJajtAMAAACWo7T/fyUlJUpPT1dCQoJGjhypzZs3u5r3v//7v/r+97+vnj17yuPx6KWXXnI1T5KKi4t1ySWXqGPHjurevbsmTZqk3bt3u567ZMkSDR06NPABBaNGjdJrr73meu63zZ8/Xx6PR3fffberOYWFhfJ4PEFfgwYNcjVTkg4ePKjbbrtNXbt2Vfv27XXhhRdqy5Ytrmamp6c32qvH49GsWbNcy2xoaNDPfvYz9evXT+3bt9eAAQM0b948uf16+qqqKt19993q27ev2rdvr9GjR+vdd991NRPuYua7g3nPvA8V5n1jlHZJa9askc/nU0FBgbZt26bMzEzl5OToyJEjrmVWV1crMzNTJSUlrmWcasOGDZo1a5Y2bdqk0tJS1dfXa/z48aqurnY1t1evXpo/f762bt2qLVu26N/+7d90ww03aOfOna7mnvTuu+9q2bJlGjp0aFjyLrjgAn322WeBr7ffftvVvOPHj+uyyy5TXFycXnvtNX344Yd6/PHH1blzZ1dz33333aB9lpaWSpJ+9KMfuZb5yCOPaMmSJVq0aJE++ugjPfLII3r00Uf1xBNPuJYpSXfeeadKS0u1cuVKffDBBxo/fryys7N18OBBV3PhDma+ezOfec+8DxXmfRMMzIgRI8ysWbMCtxsaGkzPnj1NcXFxWPIlmbVr14Yl69uOHDliJJkNGzaEPbtz587mt7/9res5VVVVZuDAgaa0tNSMGTPGzJ4929W8goICk5mZ6WrGqR544AFz+eWXhzWzKbNnzzYDBgwwfr/ftYyJEyea6dOnBx37wQ9+YKZMmeJaZk1NjYmNjTUvv/xy0PGLL77YPPTQQ67lwj3M/PDOfOZ96DDv2/a8b/OPtNfV1Wnr1q3Kzs4OHIuJiVF2drbKy8sjuDL3nThxQpLUpUuXsGU2NDRo9erVqq6uDstHm8+aNUsTJ04M+vfrtj179qhnz57q37+/pkyZogMHDria98c//lFZWVn60Y9+pO7du+uiiy7SU0895Wrmqerq6vTss89q+vTp8ng8ruWMHj1aZWVl+utf/ypJeu+99/T222/r2muvdS3zm2++UUNDgxISEoKOt2/f3vVH1RB6zPzwzXzmfegx79v4vI/0/zVE2sGDB40ks3HjxqDj9913nxkxYkRY1qAIPOrS0NBgJk6caC677LKw5L3//vvmnHPOMbGxsebcc881r7zyiuuZzz//vBkyZIj5xz/+YYwxYXnk5dVXXzUvvPCCee+998y6devMqFGjTJ8+fUxlZaVrmV6v13i9XpOfn2+2bdtmli1bZhISEsyKFStcyzzVmjVrTGxsrDl48KCrOQ0NDeaBBx4wHo/HtGvXzng8HvPLX/7S1UxjjBk1apQZM2aMOXjwoPnmm2/MypUrTUxMjPne977nejZCi5nv/sxn3jPvQ4F53xilvY0O8P/4j/8wffv2NZ9++mlY8mpra82ePXvMli1bzJw5c0xycrLZuXOna3kHDhww3bt3N++9917gWDiG+KmOHz9ukpKSXP3VcFxcnBk1alTQsZ/85Cfm0ksvdS3zVOPHjzfXXXed6znPP/+86dWrl3n++efN+++/b37/+9+bLl26uP4X1t69e82VV15pJJnY2FhzySWXmClTpphBgwa5movQY+a7P/OZ98z7UGDeN9bmS3ttba2JjY1tNECnTp1qrr/++rCsIdwDfNasWaZXr17mb3/7W9gyTzVu3Djz4x//2LXrr127NvADd/JLkvF4PCY2NtZ88803rmWfKisry8yZM8e16/fp08fccccdQccWL15sevbs6Vrmt+3fv9/ExMSYl156yfWsXr16mUWLFgUdmzdvnjn//PNdzzbGmK+++socOnTIGGPMzTffbCZMmBCWXIQOMz/8mPehw7xv2/O+zT+nPT4+XsOHD1dZWVngmN/vV1lZWViegxdOxhjl5eVp7dq1evPNN9WvX7+IrcXv96u2tta1648bN04ffPCBduzYEfjKysrSlClTtGPHDsXGxrqW/W1fffWVPv74Y/Xo0cO1jMsuu6zR27j99a9/Vd++fV3L/Lann35a3bt318SJE13PqqmpUUxM8NiKjY2V3+93PVuSzjnnHPXo0UPHjx/X66+/rhtuuCEsuQgdZn74Me9Dh3nfxud9pP+vwQarV682Xq/XrFixwnz44Yfmxz/+senUqZM5fPiwa5lVVVVm+/btZvv27UaSWbBggdm+fbv55JNPXMu86667zLnnnmvWr19vPvvss8BXTU2Na5nGGDNnzhyzYcMGs2/fPvP++++bOXPmGI/HY9544w1Xc08Vjl+X3nPPPWb9+vVm37595i9/+YvJzs42ycnJ5siRI65lbt682bRr18784he/MHv27DHPPfecSUxMNM8++6xrmSc1NDSYPn36mAceeMD1LGOMmTZtmklLSzMvv/yy2bdvn3nxxRdNcnKyuf/++13NXbdunXnttdfM3/72N/PGG2+YzMxMM3LkSFNXV+dqLtzBzHdv5jPvmfehwrxvjNL+/z3xxBOmT58+Jj4+3owYMcJs2rTJ1by33nrLSGr0NW3aNNcym8qTZJ5++mnXMo0xZvr06aZv374mPj7edOvWzYwbNy7sA9yY8AzxyZMnmx49epj4+HiTlpZmJk+ebPbu3etqpjHG/OlPfzJDhgwxXq/XDBo0yDz55JOuZxpjzOuvv24kmd27d4clr7Ky0syePdv06dPHJCQkmP79+5uHHnrI1NbWupq7Zs0a079/fxMfH29SU1PNrFmzzJdffulqJtzFzHcH8555HyrM+8Y8xrj80VIAAAAAzkibf047AAAAYDtKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABgOUo7AAAAYDlKOwAAAGA5SjsAAABguf8HqYWEiHyZytcAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "likelihood = lh_hallway(hallway, z=1, z_prob=.75)\n",
    "posterior = update(likelihood, prior)\n",
    "book_plots.plot_prior_vs_posterior(prior, posterior, ylim=(0,.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61357610",
   "metadata": {},
   "source": [
    "注意位置 1 处的tall bar。这对应于从位置 0 开始、感应一扇门、向右移动 1 并感应另一扇门的（正确）情况。 没有其他位置比这个位置更符合观测。 现在我们将添加一个更新，然后感知墙壁。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "40694d54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 继续预测移动了一个位置 \n",
    "prior = predict(posterior, 1, kernel)\n",
    "# 测量在表示在0 即表示靠墙\n",
    "likelihood = lh_hallway(hallway, z=0, z_prob=.75)\n",
    "posterior = update(likelihood, prior)\n",
    "book_plots.plot_prior_vs_posterior(prior, posterior, ylim=(0,.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e84be6fb",
   "metadata": {},
   "source": [
    "这真让人兴奋！ 我们在位置 2 有一个非常突出的条形，其值约为 35%。 它是图中任何其他条形值的两倍多，比我们上一个图中的最高条形大约 31% 大约 4%。 让我们再看一个循环。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "5bc42ec1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prior = predict(posterior, 1, kernel)\n",
    "likelihood = lh_hallway(hallway, z=0, z_prob=.75)\n",
    "posterior = update(likelihood, prior)\n",
    "book_plots.plot_prior_vs_posterior(prior, posterior, ylim=(0,.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0205729b",
   "metadata": {},
   "source": [
    "我忽略了一个重要的问题。 早些时候我假设我们有一个用于预测步骤的运动传感器； 然后，当谈到狗和微波炉时，我假设你不知道他突然开始奔跑。 我提到过你对狗正在奔跑的信念会随着时间的推移而增加，但我没有为此提供任何代码。 简而言之，如果我们不直接测量它，我们如何检测和/或估计过程模型中的变化？\n",
    "\n",
    "现在我想忽略这个问题。 在后面的章节中，我们将学习这种估计背后的数学原理； 现在，仅仅学习这个算法就已经是一个足够大的任务了。 解决这个问题非常重要，但我们还没有构建足够的数学工具，因此在本章的其余部分，**我们将假设有一个可以感知运动的传感器来忽略这个问题**。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2810c359",
   "metadata": {},
   "source": [
    "## 2.9 离散贝叶斯算法\n",
    "\n",
    "该图表说明了该算法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "d64e180c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "book_plots.predict_update_chart()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd5b1f67",
   "metadata": {},
   "source": [
    "这个过滤器是 g-h 滤波器的一种形式。 这里我们使用误差的百分比来隐式计算 $g$ 和 $h$ 参数。 我们可以将离散贝叶斯算法表示为 g-h 过滤波器，但这会掩盖该滤波器的逻辑。\n",
    "\n",
    "滤波器方程为：\n",
    "\n",
    "$$\\begin{aligned} \\bar {\\mathbf x} &= \\mathbf x \\ast f_{\\mathbf x}(\\bullet)\\, \\, &\\text{Predict Step} \\\\\n",
    "\\mathbf x &= \\|\\mathcal L \\cdot \\bar{\\mathbf x}\\|\\, \\, &\\text{Update Step}\\end{aligned}$$\n",
    "\n",
    "\n",
    "$\\mathcal L$ 是编写似然函数的常用方法，所以我使用它。 $\\|\\|$ 符号表示取范数。 我们需要将似然与先验的乘积归一化，以确保 $x$ 是一个总和为 1 的概率分布。\n",
    "\n",
    "我们可以用伪代码来表达。\n",
    "\n",
    "**初始化**\n",
    "\n",
    "     1. 初始化我们对状态的信念\n",
    "    \n",
    "**预测**\n",
    "\n",
    "     1. 根据系统行为，预测下一时间步的状态\n",
    "     2. 调整信念以解释预测的不确定性\n",
    "    \n",
    "**更新**\n",
    "\n",
    "     1. 获得关于其准确性的测量和相关信念\n",
    "     2. 计算测量与每个状态匹配的可能性\n",
    "     3. 用这种可能性更新状态信念\n",
    "     \n",
    "当我们介绍卡尔曼滤波器时，我们将使用完全相同的算法； 只有计算的细节会有所不同。\n",
    "\n",
    "这种形式的算法有时称为*预测器校正器（predictor correctors）*。 我们做出预测，然后纠正它们。\n",
    "\n",
    "让我们执行一下（这个过程）。 首先让我们编写函数来执行滤波并在任何步骤绘制结果。 我用黑色标出了门的位置。 先验用橙色绘制，后验用蓝色绘制。 我画了一条粗垂直线来指示西蒙的真实位置。 这不是滤波器的输出——我们知道西蒙在哪里只是因为我们正在模拟他的运动。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "d4331c28",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 离散贝叶斯仿真函数\n",
    "def discrete_bayes_sim(prior, kernel, measurements, z_prob, hallway):\n",
    "    posterior = np.array([.1]*10)\n",
    "    priors, posteriors = [], []\n",
    "    for i, z in enumerate(measurements):\n",
    "        prior = predict(posterior, 1, kernel)\n",
    "        priors.append(prior)\n",
    "\n",
    "        likelihood = lh_hallway(hallway, z, z_prob)\n",
    "        posterior = update(likelihood, prior)\n",
    "        posteriors.append(posterior)\n",
    "    return priors, posteriors\n",
    "\n",
    "\n",
    "def plot_posterior(hallway, posteriors, i):\n",
    "    plt.title('Posterior')\n",
    "    book_plots.bar_plot(hallway, c='k')\n",
    "    book_plots.bar_plot(posteriors[i], ylim=(0, 1.0))\n",
    "    plt.axvline(i % len(hallway), lw=5)    \n",
    "    \n",
    "def plot_prior(hallway, priors, i):\n",
    "    plt.title('Prior')\n",
    "    book_plots.bar_plot(hallway, c='k')\n",
    "    book_plots.bar_plot(priors[i], ylim=(0, 1.0), c='#ff8015')\n",
    "    plt.axvline(i % len(hallway), lw=5)    \n",
    "\n",
    "def animate_discrete_bayes(hallway, priors, posteriors):\n",
    "    def animate(step):\n",
    "        step -= 1\n",
    "        i = step // 2    \n",
    "        if step % 2 == 0:\n",
    "            plot_prior(hallway, priors, i)\n",
    "        else:\n",
    "            plot_posterior(hallway, posteriors, i)\n",
    "    \n",
    "    return animate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52bc369a",
   "metadata": {},
   "source": [
    "让我们运行滤波器并为其设置动画。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "02900003",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "de7642e36f724aa88dd80960c096efac",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=1, description='step'), Output()), _dom_classes=('widget-interact',))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# change these numbers to alter the simulation\n",
    "kernel = (.1, .8, .1)\n",
    "z_prob = 1.0\n",
    "hallway = np.array([1, 1, 0, 0, 0, 0, 0, 0, 1, 0])\n",
    "\n",
    "# measurements with no noise  进行了5个循环\n",
    "zs = [hallway[i % len(hallway)] for i in range(50)]\n",
    "print(len(zs))\n",
    "\n",
    "priors, posteriors = discrete_bayes_sim(prior, kernel, zs, z_prob, hallway)\n",
    "# print(len(priors))\n",
    "# print(posteriors)\n",
    "interact(animate_discrete_bayes(hallway, priors, posteriors), step=IntSlider(value=1, max=len(zs)*2));\n",
    "# 橙色先验 蓝色后验 ，粗线是真实位置"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d45eab42",
   "metadata": {},
   "source": [
    "现在我们可以看到结果了。 您可以看到先验如何移动位置并降低确定性，而后验保持在相同位置并增加确定性，因为它结合了测量信息。 我用`z_prob = 1.0`行使测量变得完美； 我们将在下一节探讨不完美测量的影响。 最后，另一件需要注意的事情是，当我们在门前时，我们的估计会变得多么准确，而在走廊中间时，它会如何降级。 这应该具有直观意义。 只有几个门口，所以当传感器告诉我们我们在门前时，这会增强我们对自己位置的确定性。 长时间没有门会降低我们的确定性。\n",
    "\n",
    "## The Effect of Bad Sensor Data\n",
    "\n",
    "您可能对上述结果表示怀疑，因为我总是将正确的传感器数据传递给函数。 但是，我们声称此代码实现了 *filter* - 它应该过滤掉不良的传感器测量值。 它这样做吗？\n",
    "\n",
    "为了便于编程和可视化，我将走廊的布局更改为主要是交替的门和走廊，并在 6 次正确测量上运行算法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "4c804d23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([0.167, 0.056, 0.167, 0.056, 0.056, 0.167, 0.056, 0.167, 0.056,\n",
      "       0.056]), array([0.028, 0.179, 0.032, 0.179, 0.083, 0.028, 0.179, 0.032, 0.179,\n",
      "       0.083]), array([0.134, 0.025, 0.23 , 0.032, 0.08 , 0.134, 0.025, 0.23 , 0.032,\n",
      "       0.08 ]), array([0.033, 0.144, 0.023, 0.232, 0.069, 0.033, 0.144, 0.023, 0.232,\n",
      "       0.069]), array([0.037, 0.065, 0.055, 0.076, 0.267, 0.037, 0.065, 0.055, 0.076,\n",
      "       0.267]), array([0.314, 0.029, 0.086, 0.027, 0.044, 0.314, 0.029, 0.086, 0.027,\n",
      "       0.044])]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6149641ab453404f8e305763669cce5e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=12, description='step', max=12), Output()), _dom_classes=('widget-intera…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hallway = np.array([1, 0, 1, 0, 0]*2)\n",
    "kernel = (.1, .8, .1)\n",
    "prior = np.array([.1] * 10)\n",
    "zs = [1, 0, 1, 0, 0, 1]\n",
    "z_prob = 0.75\n",
    "priors, posteriors = discrete_bayes_sim(prior, kernel, zs, z_prob, hallway)\n",
    "print(posteriors)\n",
    "interact(animate_discrete_bayes(hallway, priors, posteriors), step=IntSlider(value=12, max=len(zs)*2));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b514deef",
   "metadata": {},
   "source": [
    "我们已经确定了从位置 0 或 5 开始的可能情况，因为我们看到了门和墙的以下序列：1,0,1,0,0。 现在我注入了一个错误的测量值。 下一个测量值应该是 0，但我们得到的是 1："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "7c838f58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "measurements = [1, 0, 1, 0, 0, 1, 1]\n",
    "priors, posteriors = discrete_bayes_sim(prior, kernel, measurements, z_prob, hallway);\n",
    "plot_posterior(hallway, posteriors, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3096803e",
   "metadata": {},
   "source": [
    "这种糟糕的衡量标准已经大大侵蚀了我们的知识。 现在让我们继续进行一系列正确的测量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "889be7f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x550 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(prior)\n",
    "with figsize(y=5.5):\n",
    "    measurements = [1, 0, 1, 0, 0, 1, 1, 1, 0, 0]\n",
    "    for i, m in enumerate(measurements):\n",
    "        likelihood = lh_hallway(hallway, z=m, z_prob=.75)\n",
    "        posterior = update(likelihood, prior)\n",
    "        prior = predict(posterior, 1, kernel)\n",
    "        plt.subplot(5, 2, i+1)\n",
    "        book_plots.bar_plot(posterior, ylim=(0, .4), title=f'step {i+1}')\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9c0c4b",
   "metadata": {},
   "source": [
    "我们很快过滤掉了错误的传感器读数，并集中在我们的狗最可能的位置上。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4298b327",
   "metadata": {},
   "source": [
    "## Section 2.11: Drawbacks and Limitations 缺点和局限性\n",
    "\n",
    "不要被我选择的例子的简单性所误导。这是一个强大而完整的滤波器，您可以在现实世界的解决方案中使用该代码。如果您需要mutilmode的离散滤波器，则此滤波器有效。\n",
    "\n",
    "话虽如此，这个滤波器并不经常使用，因为它有几个限制。绕过这些限制是本书其余章节背后的动机。\n",
    "\n",
    "第一个问题是规模。我们的狗跟踪问题仅使用一个变量 $pos$ 来表示狗的位置。大多数有趣的问题都希望在一个大空间中跟踪几件事情（多维变量）。实际上，至少我们希望跟踪我们的狗的 $(x,y)$ 坐标，可能还有他的速度 $(\\dot{x},\\dot{y})$。我们没有涵盖多维情况，但我们使用多维网格代替数组来存储每个离散位置的概率。每个 `update()` 和 `predict()` 步骤都需要更新网格中的所有值，因此一个简单的四变量问题将需要 $O(n^4)$ 运行时间*每个时间步*。现实滤波器可以跟踪 10 个或更多变量，从而导致过高的计算要求。\n",
    "\n",
    "第二个问题是滤波器是离散的，但我们生活在一个连续的世界中。直方图要求您将滤波器的输出建模为一组离散点。一条 100 米长的走廊需要 10,000 个位置才能将走廊建模到 1 厘米的精度。因此，每次更新和预测操作都需要对 10,000 个不同的概率进行计算。随着我们添加维度，情况会呈指数级恶化。一个 100x100 $m^2$ 的庭院需要 100,000,000 个bins才能获得 1 厘米的精度。\n",
    "\n",
    "第三个问题是滤波器是多峰的。在最后一个例子中，我们最终坚信狗在位置 4 或 9。这并不总是一个问题。我们将在后面研究的粒子滤波器是多峰的，并且由于这个特性而经常被使用。但是想象一下，如果您汽车中的 GPS 向您报告，40% 的确定您在 D 街，30% 确定您在 Willow Avenue。\n",
    "\n",
    "第四个问题是它需要测量状态的变化。我们需要一个运动传感器来检测狗的运动量。有一些方法可以解决这个问题，但这会使本章的阐述变得复杂，因此，鉴于上述问题，我将不再进一步讨论。\n",
    "\n",
    "话虽如此，如果我有这个技术可以处理的小问题，我会选择使用它；实现、调试和理解所有优点是微不足道的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e519e52",
   "metadata": {},
   "source": [
    "## Section 2.12: Tracking and Control\n",
    "\n",
    "我们一直在被动地跟踪一个自主移动的物体。但是考虑一下这个非常相似的问题。我正在自动化仓库并希望使用机器人来收集客户订单的所有物品。也许最简单的方法是让机器人在轨道上行驶。我希望能够向机器人发送目的地并将其送到那里。但是火车轨道和机器人动力系统并不完美。车轮打滑和不完美的电机意味着机器人有时不能准确地移动到指定的位置。有不止一个机器人，我们需要知道它们都在哪里，以免导致它们坠毁。\n",
    "\n",
    "所以我们添加了传感器。也许我们每隔几英尺就在轨道上安装磁铁，并使用霍尔传感器来计算通过了多少磁铁。如果我们数到 10 个磁铁，那么机器人应该在第 10 个磁铁处。当然，有可能遗漏磁铁或计数两次，因此我们必须适应一定程度的误差。我们可以使用上一节中的代码来跟踪我们的机器人，因为磁铁计数与门口感应非常相似。\n",
    "\n",
    "但我们还没有完成。我们已经学会了永远不要丢弃信息。如果你有信息，你应该用它来改进你的估计。我们遗漏了哪些信息？我们知道我们在每个时刻向机器人的轮子提供哪些控制输入。例如，假设我们每秒向机器人发送一次运动命令 - 向左移动 1 个单位，向右移动 1 个单位，或静止不动。如果我发送命令“向左移动 1 个单位”，我预计从现在开始的一秒钟内，机器人将在现在所在位置的左侧 1 个单位。这是一种简化，因为我没有考虑加速度，但我不是在尝试教授控制理论。车轮和电机不完善。机器人最终可能会在 0.9 个单位之外，或者可能在 1.2 个单位之外。\n",
    "\n",
    "现在整个解决方案很清楚了。我们假设狗一直朝他之前移动的任何方向移动。这对我的狗来说是一个可疑的假设！相比之下，机器人的可预测性要高得多。将移动指令发送给机器人，而不是基于行为假设做出可疑的预测！换句话说，当我们调用“predict()”时，我们将传递给机器人的运动指令 这个指令包含了关于运动的似然计算所需要的核函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b88d333",
   "metadata": {},
   "source": [
    "### Section2.12.1 Simulating the Train Behavior\n",
    "\n",
    "我们需要模拟一个不完美的火车。 当我们命令它移动时，它有时会犯一个小错误，它的传感器有时会返回不正确的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "668509e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Train(object):\n",
    "\n",
    "    def __init__(self, track_len, kernel=[1.], sensor_accuracy=.9):\n",
    "        self.track_len = track_len\n",
    "        self.pos = 0\n",
    "        self.kernel = kernel\n",
    "        self.sensor_accuracy = sensor_accuracy\n",
    "\n",
    "    def move(self, distance=1):\n",
    "        \"\"\" move in the specified direction with some small chance of error\"\"\"\n",
    "        self.pos += distance\n",
    "        # insert random movement error according to kernel\n",
    "        # 根据核函数插入随机移动误差\n",
    "        r = random.random()\n",
    "        s = 0\n",
    "        offset = -(len(self.kernel) - 1) / 2 # -1 [.1, .8, .1]\n",
    "        for k in self.kernel:\n",
    "            s += k\n",
    "            if r <= s:\n",
    "                break\n",
    "            offset += 1\n",
    "        # 基于原有移动进行offset\n",
    "        if offset!=0:\n",
    "            print(\"offset:\", offset)\n",
    "        self.pos = int((self.pos + offset) % self.track_len)#更新位置时，将当前位置和计算得到的偏移量相加，并使用取余操作以确保在轨道上。\n",
    "\n",
    "        return self.pos\n",
    "\n",
    "    def sense(self):\n",
    "        pos = self.pos\n",
    "         # insert random sensor error\n",
    "        if random.random() > self.sensor_accuracy:\n",
    "            if random.random() > 0.5:\n",
    "                print(\"sensor read error+1\")\n",
    "                pos += 1\n",
    "            else:\n",
    "                print(\"sensor read error-1\")\n",
    "                pos -= 1\n",
    "        return pos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bee5b621",
   "metadata": {},
   "source": [
    "有了这个，我们就可以编写滤波器了。 我们将把它放在一个函数中，以便我们可以在不同的假设下运行它。 我会假设机器人总是从赛道的起点开始。 轨道被实现为 10 个单位长，但可以将其视为一个长度为 10,000 的轨道，磁铁 pattern 每 10 个单位重复一次。 长度为 10 可以更轻松地绘制和检查。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "ebd54ba3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_filter(iterations, kernel, sensor_accuracy, move_distance, do_print=True):\n",
    "    track = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "    prior = np.array([.9] + [0.01]*9)\n",
    "    posterior = prior[:]\n",
    "    normalize(prior)\n",
    "    \n",
    "    robot = Train(len(track), kernel, sensor_accuracy)\n",
    "    for i in range(iterations):\n",
    "        print(\"-\"*40)\n",
    "        # move the robot and\n",
    "        robot.move(distance=move_distance)\n",
    "\n",
    "        # peform prediction\n",
    "        prior = predict(posterior, move_distance, kernel)       \n",
    "\n",
    "        #  and update the filter 带随机误差的环境值，测量\n",
    "        m = robot.sense() #返回传感器的观测位置\n",
    "        # def lh_hallway(hall, z, z_prob):\n",
    "        #   \"\"\" compute likelihood that a measurement matches positions in the hallway.\"\"\"     \n",
    "        #   try:\n",
    "        #     scale = z_prob / (1. - z_prob)\n",
    "        #   except ZeroDivisionError:\n",
    "        #     scale = 1e8\n",
    "        #   likelihood = np.ones(len(hall))\n",
    "        #   likelihood[hall==z] *= scale\n",
    "        #   return likelihood\n",
    "        likelihood = lh_hallway(track, m, sensor_accuracy)\n",
    "        posterior = update(likelihood, prior)\n",
    "        index = np.argmax(posterior)  # 最大似然估计\n",
    "\n",
    "        if do_print:\n",
    "            print(f'time {i}: pos {robot.pos}, sensed {m}, at position（real positon） {track[robot.pos]}')\n",
    "            conf = posterior[index] * 100\n",
    "            print(f'estimated position is {index} with confidence {conf:.4f}%:')            \n",
    "\n",
    "    book_plots.bar_plot(posterior)\n",
    "    if do_print:\n",
    "        print()\n",
    "        print('final position is', robot.pos)\n",
    "        index = np.argmax(posterior)\n",
    "        print('''Estimated position is {} with ''''''confidence {:.4f}%:'''.format(index, posterior[index]*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63a56319",
   "metadata": {},
   "source": [
    "阅读代码并确保您理解它。 现在让我们在没有传感器或移动错误的情况下运行。 如果代码正确，它应该能够准确无误地定位机器人。 输出阅读起来有点乏味，但如果您完全不确定更新/预测周期的工作方式，请确保仔细阅读以巩固您的理解。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "id": "0ebdf1fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------\n",
      "time 0: pos 4, sensed 4, at position（real positon） 4\n",
      "estimated position is 4 with confidence 99.9900%:\n",
      "----------------------------------------\n",
      "time 1: pos 8, sensed 8, at position（real positon） 8\n",
      "estimated position is 8 with confidence 100.0000%:\n",
      "----------------------------------------\n",
      "time 2: pos 2, sensed 2, at position（real positon） 2\n",
      "estimated position is 2 with confidence 100.0000%:\n",
      "----------------------------------------\n",
      "time 3: pos 6, sensed 6, at position（real positon） 6\n",
      "estimated position is 6 with confidence 100.0000%:\n",
      "\n",
      "final position is 6\n",
      "Estimated position is 6 with confidence 100.0000%:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random.seed(3)\n",
    "np.set_printoptions(precision=2, suppress=True, linewidth=60)\n",
    "train_filter(4, kernel=[1.], sensor_accuracy=.999,\n",
    "             move_distance=4, do_print=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d04420eb",
   "metadata": {},
   "source": [
    "我们可以看到代码能够完美地跟踪机器人，所以我们应该有理由相信代码正在工作。 现在让我们看看它如何处理一些错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "61099297",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------\n",
      "time 0: pos 4, sensed 4, at position（real positon） 4\n",
      "estimated position is 4 with confidence 96.0390%:\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "time 1: pos 8, sensed 9, at position（real positon） 8\n",
      "estimated position is 9 with confidence 52.1180%:\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "time 2: pos 3, sensed 3, at position（real positon） 3\n",
      "estimated position is 3 with confidence 88.3993%:\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "time 3: pos 7, sensed 8, at position（real positon） 7\n",
      "estimated position is 8 with confidence 49.3174%:\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "time 4: pos 2, sensed 2, at position（real positon） 2\n",
      "estimated position is 2 with confidence 87.3822%:\n",
      "----------------------------------------\n",
      "time 5: pos 6, sensed 6, at position（real positon） 6\n",
      "estimated position is 6 with confidence 95.6316%:\n",
      "----------------------------------------\n",
      "time 6: pos 0, sensed 0, at position（real positon） 0\n",
      "estimated position is 0 with confidence 96.7677%:\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "time 7: pos 3, sensed 3, at position（real positon） 3\n",
      "estimated position is 3 with confidence 52.5870%:\n",
      "\n",
      "final position is 3\n",
      "Estimated position is 3 with confidence 52.5870%:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random.seed(5)\n",
    "train_filter(8, kernel=[.1, .8, .1], sensor_accuracy=.9,\n",
    "         move_distance=4, do_print=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec0ec4b9",
   "metadata": {},
   "source": [
    "在时间 1 有一个感应错误，但我们仍然对我们的位置很有信心。\n",
    "\n",
    "现在让我们运行一个很长的模拟，看看滤波器如何响应错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "id": "1f318322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: 1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "offset: -1.0\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error+1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "sensor read error-1\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n",
      "----------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x550 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with figsize(y=5.5):\n",
    "    for i in range (4):\n",
    "        random.seed(3)\n",
    "        plt.subplot(221+i)\n",
    "        train_filter(148+i, kernel=[.1, .8, .1], \n",
    "                     sensor_accuracy=.8,\n",
    "                     move_distance=4, do_print=False)\n",
    "        plt.title (f'iteration {148 + i}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b477e9",
   "metadata": {},
   "source": [
    "我们可以看到，随着置信度的降低，第 149 次迭代出现了问题。 但是在几次迭代中，滤波器能够自我纠正并重新获得对估计位置的信心。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99718742",
   "metadata": {},
   "source": [
    "## Bayes Theorem and the Total Probability Theorem\n",
    "\n",
    "我们仅仅通过推理我们在每一时刻所拥有的信息来发展本章中的数学。在这个过程中，我们发现了 [*Bayes' Theorem*](https://en.wikipedia.org/wiki/Bayes%27_theorem) 和 [*Total Probability Theorem*](https://en.wikipedia.org/wiki /Law_of_total_probability）。\n",
    "\n",
    "贝叶斯定理告诉我们如何计算给定先前信息的事件的概率。\n",
    "\n",
    "我们用这个概率计算实现了 `update()` 函数：\n",
    "\n",
    "$$ \\mathtt{posterior} = \\frac{\\mathtt{likelihood}\\times \\mathtt{prior}}{\\mathtt{normalization\\, factor}}$$\n",
    "\n",
    "我们还没有开发数学来讨论贝叶斯，但这是贝叶斯定理。本书中的每个滤波器都是贝叶斯定理的表达。在下一章中，我们将发展数学，但在许多方面会掩盖这个等式表达的简单思想：\n",
    "\n",
    "$$ 更新\\,知识 = \\big\\|likelihood\\,of\\,new\\,knowledge\\times prior\\, Knowledge \\big\\|$$\n",
    "\n",
    "$\\| \\cdot\\|$ 表示将术语标准化。\n",
    "\n",
    "我们通过简单的推理得出了这一点，即一只狗在走廊上行走。然而，正如我们将看到的，同样的方程适用于一系列过滤问题。我们将在随后的每一章中使用这个等式。\n",
    "\n",
    "同样，“predict()”步骤计算多个可能事件的总概率。这在统计学中被称为*总概率定理*，在开发了一些辅助数学之后，我们还将在下一章中介绍它。\n",
    "\n",
    "现在，我需要您了解贝叶斯定理是将新信息合并到现有信息中的公式。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed6d2cff",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "\n",
    "代码很短，但结果令人印象深刻！我们已经实现了一种形式的贝叶斯过滤器。我们已经学会了如何从无信息开始，并从嘈杂的传感器中获取信息。尽管本章中的传感器非常嘈杂（例如，大多数传感器的准确率超过 80%），但我们仍能迅速收敛到我们的狗最可能的位置。我们已经了解了预测步骤如何总是降低我们的知识，但是添加另一个测量，即使它可能有噪音，也会提高我们的知识，使我们能够收敛到最可能的结果。\n",
    "\n",
    "这本书主要是关于卡尔曼滤波器。它使用的数学方法不同，但逻辑与本章使用的完全相同。它使用贝叶斯推理从测量和过程模型的组合中形成估计。\n",
    "\n",
    "**如果你能理解本章，你将能够理解和实现卡尔曼滤波器。**我怎么强调这一点都不为过。如果有任何不清楚的地方，请返回并重新阅读本章并使用代码。本书的其余部分将建立在我们在这里使用的算法之上。如果您不理解此过滤器的工作原理，您将无法在其余材料上取得成功。但是，如果您掌握了基本的见解——在我们测量时乘以概率，并在我们更新时改变概率导致收敛解决方案——那么在学习了一些数学之后，您就可以准备实施卡尔曼滤波器了。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fd59770",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    " * [1] D. Fox, W. Burgard, and S. Thrun. \"Monte carlo localization: Efficient position estimation for mobile robots.\" In *Journal of Artifical Intelligence Research*, 1999.\n",
    " \n",
    " http://www.cs.cmu.edu/afs/cs/project/jair/pub/volume11/fox99a-html/jair-localize.html\n",
    "\n",
    "\n",
    " * [2] Dieter Fox, et. al. \"Bayesian Filters for Location Estimation\". In *IEEE Pervasive Computing*, September 2003.\n",
    " \n",
    " http://swarmlab.unimaas.nl/wp-content/uploads/2012/07/fox2003bayesian.pdf\n",
    " \n",
    " \n",
    " * [3] Sebastian Thrun. \"Artificial Intelligence for Robotics\".\n",
    " \n",
    " https://www.udacity.com/course/cs373\n",
    " \n",
    " \n",
    " * [4] Khan Acadamy. \"Introduction to the Convolution\"\n",
    " \n",
    " https://www.khanacademy.org/math/differential-equations/laplace-transform/convolution-integral/v/introduction-to-the-convolution\n",
    " \n",
    " \n",
    "* [5] Wikipedia. \"Convolution\"\n",
    "\n",
    " http://en.wikipedia.org/wiki/Convolution\n",
    "\n",
    "* [6] Wikipedia. \"Law of total probability\"\n",
    "\n",
    "  http://en.wikipedia.org/wiki/Law_of_total_probability\n",
    "  \n",
    "* [7] Wikipedia. \"Time Evolution\"\n",
    "\n",
    " https://en.wikipedia.org/wiki/Time_evolution\n",
    " \n",
    "* [8] We need to rethink how we teach statistics from the ground up\n",
    " \n",
    " http://www.statslife.org.uk/opinion/2405-we-need-to-rethink-how-we-teach-statistics-from-the-ground-up"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
